0

我正在开发一个 c++ 项目，以前从未真正使用过头文件，我正在尝试构建我的项目，但是它引发了几个链接器错误，我不知道它们是什么或如何修复它们！

错误如下：

错误 4 error LNK1120: 3 unresolved externals C:\Users\Stephen\Downloads\08227_ACW2_TestHarness_12-13\08227_ACW2_TestHarness_12-13\Debug\08227_ACW.exe 1 1 08227_ACW

错误 3 error LNK2019: unresolved external symbol " 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 C:\Users\Stephen\Downloads\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 C:\Users\Stephen\Downloads\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> >)" (?exists@LinkedListStorage@@QAE_NV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z) 中引用功能 _main C:\Users\Stephen\Downloads\08227_ACW2_TestHarness_12-13\08227_ACW2_TestHarness_12-13\main.obj 08227_ACW

从周围阅读它们是某种链接器错误，但我完全不知道实际问题是什么。我什至不知道把我的代码放上去是否会有所帮助，如果需要的话，有人可以告诉我，我会放上去的。

提前致谢！

编辑：

头文件：

数组存储.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

链表存储.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

主文件

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

链表存储.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;
}

抱歉，文字墙太大了，如果不需要，请告诉我，我会删除它！

4

1 回答 1

1

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

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

bool ArrayStorage::exists(string target) {
    // Function body here
}
于 2013-05-06T12:16:54.203 回答