C++ 创建包含链表和字符串的对象的链接列表时出错

Question

在下面的程序中，我正在创建一个具有一个string和一个linkedlist<int>的对象。

由于main()obj，我一直遇到未解决的问题。错误说：

错误 LNK2019：未解析的外部符号"公共：__thiscall List：：List(class List const &)" (??0？$List@H@@QAE@ABV0@@Z) 在函数"public： __thiscall Data：:D ata(class Data const &)" (？？0Data@@QAE@ABV0@@Z)

main.cpp
#include "List.h"
#include <string>
#include <iostream>
#include <fstream>
#include <utility> 
using namespace std;
template <class Object>
void printList( const List<Object> & theList )  // SIMPLE PRINT FUNCTION
{
if( theList.isEmpty( ) )
cout << "Empty list" << endl;
else
{
ListItr<Object> itr = theList.first( );
for( ; !itr.isPastEnd( ); itr.advance( ) )
cout << itr.retrieve( ) << " ";
}
cout << endl;
}
class Data
{
public:
Data(){
keyword = "";
List<int> pages;
}
void addNewData(string key, int article){
ListItr<int> pageitr = pages.zeroth();
keyword = key;
pages.insert(article, pageitr);
}
void addNewPage(int article){
ListItr<int> pageitr = pages.zeroth();
if(!pages.isExist(article))
pages.insert(article, pageitr);
}

bool operator==( const Data & rhs ){
if( this->keyword == rhs.keyword)
{
return true;
}
return false;
}
bool  operator!=( const Data & rhs ){
if( this->keyword != rhs.keyword )
{
return true;
}
return false;
}
private:
string keyword;
List<int> pages;
};

int main( )
{
List<Data> trialdata;
ListItr<Data> dataItr;
ifstream input;  
string s,k;
int count = 0;
string filename = "docdb.txt"; 
input.open(filename.c_str());
if (input.fail() )
{   cout << "could not open file " << filename << endl;
return 0;
}
/*while(input >> s){
input >> k;
addtoList(s, stoi(k), *trialdata);
}*/

return 0;
}

与此主节点相关的标头称为List.h。它取自我的课程幻灯片。我又添加了一个函数，并在没有我创建的对象的情况下对其进行了测试。它工作正常。因此，我认为我的对象存在问题，它无法在链表内创建链表。

#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

Answer 1

你的标头声明了List模板的复制构造函数：

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

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

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

编译器报告的错误是经典的未定义符号错误，这是由于缺少模板方法实例化所致。

您需要在头文件中实现并定义此模板的复制构造函数。

Answer 2

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

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

链接器抱怨它找不到List(const List &)的实现(在复制pages成员¹时，编译器生成的复制构造函数为Data调用该实现。

通常的做法是使用复制构造函数实现复制赋值运算符，例如：

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;
}
...
};

^{1：顺便说一句，根本不需要您的Data()默认构造函数。std::string有自己的默认构造函数，因此Data::keyword成员的初始化是多余的，构造函数正在声明一个名为pages的未使用的局部List变量，该变量隐藏Data:::pages成员。 由于List也有一个默认构造函数，因此无需尝试显式初始化Data::pages成员。}