创建包含链表和字符串的对象的链表的C++错误

在下面的程序中，我用一个字符串和一个linkedlist创建一个对象

由于主要是obj，我一直遇到一个未解决的问题。错误显示：

错误LNK2019:未解析的外部符号公共：\ uu thiscall 列表：：Listclass列表常量& ??0?$List@H@@QAE@ABV0@@函数public中引用的Z:\uuu thiscall 数据：：数据类数据常量和？0数据@@QAE@ABV0@@Z

---

标题声明列表模板的副本构造函数：

template<class Object>
class List
{
    // ...
    List( const List & rhs );

但是，此复制构造函数没有在任何地方定义

因此，在编译此翻译单元时，编译器将假定模板实例将在另一个翻译单元中定义并发出外部符号引用。由于复制构造函数没有在任何地方定义，因此程序无法链接

编译器报告的错误是典型的未定义符号错误，原因是缺少模板方法实例化

您需要实现并定义此模板的复制构造函数。

您为列表声明了一个复制构造函数，但没有实现它：

1：顺便说一句，您的数据默认构造函数根本不需要。std:：string有自己的默认构造函数，因此您对Data:：keyword成员的初始化是多余的，并且该构造函数正在声明一个未使用的名为pages的本地列表变量，该变量隐藏了Data:：：pages成员。由于List还有一个默认构造函数，所以不需要显式初始化Data:：pages成员

#ifndef LIST_H
#define LIST_H
using namespace std; 
#include <iostream>

template <class Object>
class List;     // Incomplete declaration.

template <class Object>
class ListItr;     // Incomplete declaration.

class  BadIterator {
public:
    BadIterator() {}
};


template <class Object>
class ListNode
{
    ListNode( const Object & theElement = Object( ),           
        ListNode * n = NULL )
        : element( theElement ), next( n ) { }

    Object   element;
    ListNode *next;

    friend class List<Object>;
    friend class ListItr<Object>;
};

template <class Object>
class ListItr
{
public:
    ListItr( ) : current( NULL ) { }
    bool isPastEnd( ) const
    { return current == NULL; }
    void advance( )
    { if( !isPastEnd( ) ) current = current->next; }
    const Object & retrieve( ) const
    { if( isPastEnd( ) ) throw BadIterator();
    return current->element; }

private:
    ListNode<Object> *current;    // Current position

    ListItr( ListNode<Object> *theNode )
        : current( theNode ) { }

    friend class List<Object>; // Grant access to constructor
};

template <class Object>
class List
{
private:
    ListNode<Object> *header;

public:
    List( ){
        header = new ListNode<Object>;
    }
    List( const List & rhs );
    ~List( )        {
        makeEmpty( );  // Get rid of all list nodes
        delete header;  // then get rid of the header
    }

    bool isEmpty( ) const{  // see if the header  point to NULL 
        return header->next == NULL;
    }
    void makeEmpty( ){
        while( !isEmpty( ) )
            remove( first( ).retrieve( ) );
    }
    ListItr<Object> zeroth( ) const{
        return ListItr<Object>( header );
    }
    ListItr<Object> first( ) const{
        return ListItr<Object>( header->next );
    }
    void insert( const Object & x, const ListItr<Object> & p ){
        if( p.current != NULL )
            p.current->next = new ListNode<Object>( x, p.current->next );
    }
    ListItr<Object> find( const Object & x ) const{
        ListNode<Object> *itr = header->next; // Initialize

        while( itr != NULL && itr->element != x )
            itr = itr->next;

        return ListItr<Object>( itr );
    }

        bool isExist( const Object & x ) const{
        ListNode<Object> *itr = header->next; // Initialize

        while( itr != NULL){
            if(itr->element == x)
                return true;
            itr = itr->next;
        }
        return false;
    }


    ListItr<Object> findPrevious( const Object & x ) const{
        ListNode<Object> *itr = header;

        while((itr->next != NULL) && itr->next->element != x )
            itr = itr->next;

        return ListItr<Object>( itr );
    }
    void remove( const Object & x ){
        ListItr<Object> p = findPrevious( x );

        if( p.current->next != NULL )
        {
            ListNode<Object> *oldNode = p.current->next;
            p.current->next = p.current->next->next;  // Bypass deleted node
            delete oldNode;
        }
    }

    const List & operator=( const List & rhs ){
        if( this != &rhs )
        {
            makeEmpty( );

            ListItr<Object> ritr = rhs.first( );
            ListItr<Object> itr = zeroth( );
            for( ; !ritr.isPastEnd( ); ritr.advance( ), itr.advance( ) )
                insert( ritr.retrieve( ), itr );
        }
        return *this;
    }

};

#endif

template<class Object>
class List
{
    // ...
    List( const List & rhs );

template <class Object>
class List
{
    ...
public:
    ...
    List( const List & rhs ); // <-- DECLARATION ONLY!
    ...
};

template <class Object>
class List
{
    ...    
public:
    ...

    List( const List & src ){
        header = new ListNode<Object>;
        ListItr<Object> sitr = src.first( );
        ListItr<Object> itr = zeroth( );
        for( ; !sitr.isPastEnd( ); sitr.advance( ), itr.advance( ) )
            insert( sitr.retrieve( ), itr );
        }
    }

    ...

    List& operator=( const List & rhs ){
        if( this != &rhs )
        {
            List<Object> temp(rhs);
            std::swap(temp.header, header);
        }
        return *this;
    }
    ...
};