问将前向列表复制到不起作用的链接列表

EN

#include <iostream>
#include <map>
#include<forward_list>
using namespace std;


#include <iostream>

using namespace std;




class Node {
public:
    int data;
    Node* next = nullptr;

};



int main() {
  forward_list<int> flist1;
  flist1 = {1,2,3,4,5,6,5,3,7,3,5,2,6,3,6,34,3,65,6};
  
    Node * head = nullptr;
  Node * temp = head;
  
  
  


  
for (auto it = flist1.begin() ; it != flist1.end(); it++){
  if (head == nullptr){
    head = new Node();
    head->data = *it;
    temp = head;
  }else{
    if(temp != nullptr){
      temp->next = new Node();
      temp->next->data = *it;
      temp = temp->next;
    }
  }


  
  //temp->next = new Node();
 //temp->next->data = *it;
 // temp = temp->next;
}
  
temp = head;
  
while (temp != nullptr){
  cout << temp->data<< endl;
  temp = temp->next;
}
  
}

// Constructor from initializer list
// ***For you to implement

// This implements the functionality you see with, for example, 
// std::forward_list<int> my_list = {1,2,3}
// which creates a new linked list where the first node holds 1, second 2, and 
// third 3.
// The {1,2,3} here is of type std::initializer_list<int> and you 
// see this is the argument to this constructor (with data of type T
// rather than just int). 

// You can access the elements of a std::initializer_list via an iterator
// for example you can cycle through all the elements with
// for(auto it = input.begin(); it!= input.end(); ++it){Do something with *it} 
template <typename T>
Forward_list<T>::Forward_list(std::initializer_list<T> input)
{
    head_ = nullptr;
    Node * temp = head_;
for (auto it = input.begin(); it != input.end(); it++){
  if (head_ == nullptr){
    head_ = new Node(*it);
    temp = head_;
  }else{
    if(temp != nullptr){
      temp->next = new Node(*it);
      temp = temp->next;
    }
  }
  temp = head_;
  
    }



}

#endif

template <typename T>
class Forward_list
{
public:
    class Node
    {
    public:
        // A node will hold data of type T
        T data{};
        // next will point to the next node in the list
        // we initialise next to nullptr
        Node* next = nullptr;

        // Because we have already intialised the variables
        // the default constructor doesn't need to do anything
        Node(){}

        // To make life easier we also provide a constructor
        // that takes the T data to be copied into the data member variable 
        // There is an optional second argument which is
        // used to update the next pointer.  This defaults to nullptr 
        // if the constructor is called with just one argument.
        Node(T input_data, Node* next_node= nullptr)
        {
            data = input_data;
            next = next_node;
        }

        // Destructor
        ~Node(){}
    };

private:
    // private member variables for Forward_list
    // the trailing underscore is a stylistic choice to 
    // distinguish these as private member variables
    unsigned size_ = 0;
    Node* head_ = nullptr;

void test_initializer_list(void)
    {
        std::initializer_list<int> inputs = {5,23,1,105,-2,7,88,0};
        Forward_list<int> my_list {inputs};
        std::forward_list<int> real_list {inputs};
        for(unsigned i=8; i>0; --i)
        {
            assert(my_list.front() == real_list.front());
            assert(my_list.size() == i);
            real_list.pop_front();
            my_list.pop_front();
        }
    }