LNK 1120 + LNK2019错误

Question

我工作的一个C++项目之前从来没有真正使用头文件，我想不过来构建我的项目是扔了几个链接错误，我不知道它们是什么或如何去修理它们！

的误差如下：

错误4错误LNK1120：3周解析的外部C：\ Users \用户斯蒂芬\下载\ 08227_ACW2_TestHarness_12-13 \ 08227_ACW2_TestHarness_12-13 \调试\ 08227_ACW.exe 1 1 08227_ACW

错误3错误LNK2019：无法解析的外部符号“public: bool __thiscall ArrayStorage::exists(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)”（？exists @ ArrayStorage @@ QAE_NV？$ basic_string @ DU？$ char_traits @ D @ std @@ V？$ allocator @ D @ 2 @@ std @@@ Z）函数_mainç引用：\ Users \用户斯蒂芬\下载\ 08227_ACW2_TestHarness_12-13 \ 08227_ACW2_TestHarness_12-13 \ main.obj 08227_ACW

错误2错误LNK2019：无法解析的外部符号“public: bool __thiscall ArrayStorage::stdExists(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)”（？stdExists @ ArrayStorage @@ QAE_NV？$ basic_string @ DU？$ char_traits @ D @ std @@ V？$ allocator @ D @ 2 @@ std @@@ Z ）在函数_mainç引用：\ Users \用户斯蒂芬\下载\ 08227_ACW2_TestHarness_12-13 \ 08227_ACW2_TestHarness_12-13 \ main.obj 08227_ACW

错误1错误LNK2019：解析的外部符号 “public: bool __thiscall LinkedListStorage::exists(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)”（存在@ @@ LinkedListStorage QAE_NV？ $ basic_string的@ $ DU @ char_traits @ d STD @@ V $分配器@ d @ @@ 2 STD @@@ Z）函数_mainç引用：？\ Users \用户斯蒂芬\下载\ 08227_ACW2_TestHarness_12-13 \ 08227_ACW2_TestHarness_12-13 \ main.obj 08227_ACW

从阅读各地他们是某种链接器错误，但我完全不知道实际问题是什么。我甚至不知道是否将我的代码放在一起会有所帮助，如果需要的话可以让别人知道我的意思，我会把它放好。

在此先感谢！

编辑：

的头文件：

ArrayStorage.h

#ifndef mao 
#define mao 

#include <fstream> 
#include <string> 
#include <iostream> 
#include <algorithm> 

using namespace std; 

class ArrayStorage 
{ 
private: 
    string* storageArray; 
    int aSize; 
public: 
    void read(ifstream& iFile); 
    void write(ofstream& oFile); 
    bool exists(string target); 
    bool stdExists(string target); 
friend ofstream& operator<<(ofstream& OS, ArrayStorage& SA); 
friend ifstream& operator>>(ifstream& IS, ArrayStorage& SA); 
}; 

#endif 

LinkedListStorage.h

#ifndef lao 
#define lao 

#include <fstream> 
#include <string> 
#include <iostream> 
#include <algorithm> 

using namespace std; 

class LinkedListStorage 
{ 
private: 
    void addnode(string line); 
    void sort(); 
    typedef struct node; 
public: 
    node *root; 
    int size; 
    void read(ifstream& iFile); 
    void write(ofstream& oFile); 
    bool exists(string target); 

friend ofstream& operator<<(ofstream& OS,LinkedListStorage& LLS); 
friend ifstream& operator>>(ifstream& IS, LinkedListStorage& LLS); 

}; 

#endif 

main.ccp

#include <fstream> 
#include <iostream> 
using namespace std; 

// ***************************** 
// you need to create these classes 
// ***************************** 
#include "ArrayStorage.h" 
#include "LinkedListStorage.h" 


int main(int argc, char **argv) { 
string find = "pixel"; 

// ###################################################### 
// #################### ArrayStorage #################### 
// ###################################################### 

// *********************************** 
//  sort read & exists 
// *********************************** 
ifstream fin1("ACW2_data.txt"); 
ofstream out1("1-In-SortedRead.txt"); 

if(!fin1.is_open()) 
{ 
    cout << "FAIL" << endl; 
    return 1; 
} 

ArrayStorage arrayStorage1; 

// read in values into data structure 
arrayStorage1.read(fin1); 

// output values in data structure to file 
arrayStorage1.write(out1); 

fin1.close(); 
out1.close(); 

// find an item in the data structure using own search method 
if(arrayStorage1.exists(find)) { 
    cout << find.c_str() << " found exists()" << endl; 
} else { 
    cout << find.c_str() << " not found exists()" << endl; 
} 

// find an item in the data structure using std::count method 
if(arrayStorage1.stdExists(find)) { 
    cout << find.c_str() << " found stdExists()" << endl; 
} else { 
    cout << find.c_str() << " not found stdExists()" << endl; 
} 



// ********************************* 
// sort read & then copy constructor 
// ********************************* 
ifstream fin2("ACW2_data.txt"); 
ofstream out2("2-Out-CopyConstructor.txt"); 

if(!fin2.is_open()) 
{ 
    cout << "FAIL" << endl; 
    return 1; 
} 

ArrayStorage arrayStorage2; 

// read in values into data structure 
arrayStorage2.read(fin2); 

ArrayStorage arrayStorage3 = arrayStorage2; 

// output values in data structure to a file 
arrayStorage3.write(out2); 

fin2.close(); 
out2.close(); 



// ************************************* 
// >> read & then << write 
// ************************************* 
ifstream fin3("ACW2_data.txt"); 
ofstream out3("3-In-OperatorRead.txt"); 
ofstream out4("4-Out-OperatorWrite.txt"); 

if(!fin3.is_open()) 
{ 
    cout << "FAIL" << endl; 
    return 1; 
} 

ArrayStorage arrayStorage4; 

fin3 >> arrayStorage4; 
arrayStorage4.write(out3); 

out4 << arrayStorage4; 

fin3.close(); 
out3.close(); 
out4.close(); 



// ########################################################### 
// #################### LinkedListStorage #################### 
// ########################################################### 

// *********************************** 
//  sort read & exists 
// *********************************** 
ifstream fin4("ACW2_data.txt"); 
ofstream out5("5-In-SortedRead.txt"); 

if(!fin4.is_open()) 
{ 
    cout << "FAIL" << endl; 
    return 1; 
} 

LinkedListStorage llStorage1; 

// read in values into data structure 
llStorage1.read(fin4); 

// output values in data structure to file 
llStorage1.write(out5); 

fin4.close(); 
out5.close(); 

// find an item in the data structure using own search method 
if(llStorage1.exists(find)) { 
    cout << find.c_str() << " found exists()" << endl; 
} else { 
    cout << find.c_str() << " not found exists()" << endl; 
} 


// ********************************* 
// sort read & then copy constructor 
// ********************************* 
ifstream fin5("ACW2_data.txt"); 
ofstream out6("6-Out-CopyConstructor.txt"); 

if(!fin5.is_open()) 
{ 
    cout << "FAIL" << endl; 
    return 1; 
} 

LinkedListStorage llStorage2; 

// read in values into data structure 
llStorage2.read(fin5); 

LinkedListStorage llStorage3 = llStorage2; 

// output values in data structure to a file 
llStorage3.write(out6); 

fin5.close(); 
out6.close(); 


// ************************************* 
// >> read & then << write 
// ************************************* 
ifstream fin6("ACW2_data.txt"); 
ofstream out7("7-In-OperatorRead.txt"); 
ofstream out8("8-Out-OperatorWrite.txt"); 

if(!fin6.is_open()) 
{ 
    cout << "FAIL" << endl; 
    return 1; 
} 

LinkedListStorage llStorage4; 

fin6 >> llStorage4; 
llStorage4.write(out7); 

out8 << llStorage4; 

fin6.close(); 
out7.close(); 
out8.close(); 

cout << endl << "Finished" << endl; 
int keypress; cin >> keypress; 
return 0; 
} 

LinkedListStorage.ccp

#include <fstream> 
#include <string> 
#include <iostream> 
#include <algorithm> 

using namespace std; 

class LinkedListStorage 
{ 
private: 
//methods 

//variables 
typedef struct node 
{ 
    string word;// data 
    node *next; //address of next node 
}; 
node *root; //root node 
int size; //size of datafile 
    public: 
//methods 
void addnode(string line) 
{ 
    node *temp, *temp2; 
    temp = new node; 

    temp->word = line; 
    temp->next = NULL; 

    if(root == NULL) 
     root = temp; 
    else 
    { 
     temp2 = root; 
     while(temp2->next != NULL) 
      temp2 = temp2->next; 
     temp2->next = temp; 
    } 
} 
void sort()//simple bubblesort 
{ 
    node *temp, *temp2; 
    temp = new node; 
    temp2 = new node; 

    string spare = 0; 
    for(temp = root; temp!=NULL;temp = temp->next) 
    { 
     if(temp->word > temp2->word) 
     { 
      spare = temp->word; 
      temp->word = temp2->word; 
      temp2->word = spare; 
     } 
    } 

} 
void read(ifstream& iFile) 
{ 
    size = 0; 
    string line; 
    if(iFile.is_open()) 
    { 
     while(std::getline(iFile, line)) 
      ++size; //Figures out the size for the dynamic array 
    } 
    root = new node; 
    root->next = 0;//null 
    root->word = ""; //no data yet 

    for (int i = 0; i < size; i++) 
    { 
     if(i<3) 
      iFile.ignore(); 
     getline(iFile,line); 
     addnode(line); 
     sort(); 
    } 

} 
void write(ofstream& oFile) 
{ 
    node *temp; 
    temp = root; 
    while (temp!=NULL) 
    { 
     oFile << temp->word << endl; 
     temp = temp->next; 
    } 
} 
bool exists(string target) //I cant think of a single way to search a singly linked  list that is faster than O(n) 
{ 
    node *temp; 
    temp = root; 
    while (temp!=NULL) 
    { 
     if (temp->word == target) 
      return true; 
    } 
    return false; 
} 
//Constructor 
LinkedListStorage(); 
//Destructor 
~LinkedListStorage() 
{ 
    node *ptr; 

    for (ptr = root; root;ptr = root) 
    { 
     root = root->next; 
     delete ptr; 
    } 
} 

LinkedListStorage(const LinkedListStorage &other) :root(NULL) 
{ 
    node *cur = other.root; 
    node *end = NULL; 

    while(cur) 
    { 
     node* x = new node; 
     x->word = cur->word; 

     if(!root) 
     { 
      root = x; 
      end = root; 
     } 
     else 
     { 
      end->next = x; 
      end = x; 
     } 

     cur = cur->next; 
    } 
} 
friend ofstream& operator<<(ofstream& OS,LinkedListStorage& LLS); 
friend ifstream& operator>>(ifstream& IS, LinkedListStorage& LLS); 

}; 

ofstream& operator<<(ofstream& OS, LinkedListStorage& LLS) 
{ 
LLS.write(OS); 
return OS; 
} 

ifstream& operator>>(ifstream& IS, LinkedListStorage& LLS) 
{ 
LLS.read(IS); 
return IS; 
} 

and finally ArrayStorage.ccp 



#include <fstream> 
#include <string> 
#include <iostream> 
#include <algorithm> 

using namespace std; 


class ArrayStorage 
{ 
//Variables 
private: string* storageArray; 
    int aSize; // array size 
public: 
//methods 
void read(ifstream& iFile) 
{ 
    aSize = 0; //intialise 
    string line; 
    if(iFile.is_open()) 
    { 
     while(std::getline(iFile, line)) 
      ++aSize; //Figures out the size for the dynamic array 
    } 
    string *pnArray = new string[aSize];//intialise array 
    for (int i = 0; i < aSize; i++) 
    { 
     if(i<3) 
     { 
      iFile.ignore(); 
     } 
     getline(iFile,pnArray[i]); //this should not contain any important data due to the way sorting is done 
     sort(pnArray,pnArray + i); //sorts the array 
    } 
    storageArray = pnArray; 
} 
void write(ofstream& oFile) 
{ 
    if(oFile.is_open()) 
    { 
     for (int j = 0; j < aSize; j++) 
     { 
      oFile << storageArray[j] << endl; 
     } 
    } 
} 
bool exists(string target) 
{ 
    int lo = 1; 
    int hi = aSize - 1; 
    int mid = 0; 
    int comparitor = 0; 
    while(true) 
    { 
     mid =(lo+hi+1)/2; // the plus one is to force it to round up to the nearest highest integer 
     if(mid == hi) 
     { 
      if(comparitor = target.compare(storageArray[lo]) == 0) 
      { 
       return true; 
      } 
      else if(comparitor = target.compare(storageArray[hi]) == 0) 
      { 
       return true; 
      } 
      else 
      { 
      return false; 
      } 
     } 
     comparitor = target.compare(storageArray[mid]); 
     if(comparitor == 0) 
      return true; 
     else if(comparitor > 0) 
      lo = mid; 
     else if(comparitor < 0) 
      hi = mid;   
    } 
} 
bool stdExists(string target) 
{ 
    int check = count(storageArray,storageArray+(aSize-1),target); 
    if(check >0) 
     return true; 
    else 
     return false; 
} 
//copy constructor 
ArrayStorage(const ArrayStorage &other) 
{ 
    storageArray = new string[other.aSize]; 
    aSize = other.aSize; 
    memcpy(storageArray,other.storageArray,sizeof(string) * aSize); 
} 
//constructor 
ArrayStorage(); 
//Destructor 
~ArrayStorage() 
{ 
    delete [] storageArray; 
} 
//overload operator 
const ArrayStorage &operator=(const ArrayStorage &other) 
{ 
    if(this == &other) return *this; 
    delete[] storageArray; 
    storageArray = new string[other.aSize]; 
    aSize = other.aSize; 
    memcpy(storageArray,other.storageArray,sizeof(string) * aSize); 
    return *this; 

    //Friends for benefit 

} 
friend ofstream& operator<<(ofstream& OS, ArrayStorage& SA); 
friend ifstream& operator>>(ifstream& IS, ArrayStorage& SA); 
}; 

ofstream& operator<<(ofstream& OS, ArrayStorage& SA) 
{ 
SA.write(OS); 
return OS; 
} 

ifstream& operator>>(ifstream& IS, ArrayStorage& SA) 
{ 
SA.read(IS); 
return IS; 
} 

对不起，文字的大规模墙，如果它的任何不需要请让我知道，我会删除！

Answer 1

您的源文件正在重新定义每个类;他们不应该那样做。相反，他们应该包含定义该类的标头，然后定义该类中声明的每个函数。例如：

// ArrayStorage.cpp 
#include "ArrayStorage.h" 

bool ArrayStorage::exists(string target) { 
    // Function body here 
}