LNK 1120 + LNK2019 Erreur

Question

Je travaille sur un projet C++ et je n'ai jamais vraiment utilisé de fichiers d'en-tête auparavant, j'essaye de construire mon projet mais il génère plusieurs erreurs de liens, je n'ai aucune idée de quoi ils sont ou comment pour y remédier!

Les erreurs sont les suivantes:

Erreur 4 Erreur LNK1120: 3 unresolved externals C: \ Users \ Stephen \ Téléchargements \ 08227_ACW2_TestHarness_12-13 \ 08227_ACW2_TestHarness_12-13 \ Debug \ 08227_ACW.exe 1 1 08227_ACW

Erreur 3 erreur LNK2019: symbole externe non résolu "public: bool __thiscall ArrayStorage::exists(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)" (? Existe @ ArrayStorage @@ QAE_NV? $ Basic_string @ DU? $ Char_traits @ D @ std @@ V? $ Allocator @ D @ 2 @@ std @@@ Z) référencé dans la fonction _main C: \ Users \ Stephen \ Downloads \ 08227_ACW2_TestHarness_12-13 \ 08227_ACW2_TestHarness_12-13 \ main.obj 08227_ACW

Erreur 2 erreur LNK2019: symbole externe non résolu "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) fait référence en fonction _main C: \ Users \ Stephen \ Téléchargements \ 08227_ACW2_TestHarness_12-13 \ 08227_ACW2_TestHarness_12-13 \ main.obj 08227_ACW

erreur 1 LNK2019 d'erreur: symbole externe non résolu "public: bool __thiscall LinkedListStorage::exists(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)" (existe @ LinkedListStorage @@ QAE_NV? $ basic_string @ DU? $ char_traits @ D @ std @@ V? $ allocateur @ D @ 2 @@ std @@@ Z) référencé dans la fonction _main C: \ Users \ Stephen \ Downloads \ 08227_ACW2_TestHarness_12-13 \ 08227_ACW2_TestHarness_12-13 \ main.obj 08227_ACW

De la lecture autour ils sont une sorte d'erreur de lien, mais je n'ai absolument aucune idée de ce qu'est le problème réel. Je ne sais même pas si le fait de mettre mon code en place m'aidera, si quelqu'un le sait, quelqu'un le fera savoir et je le mettrai en place.

Merci d'avance!

EDIT:

les fichiers d'en-tête:

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

Désolé pour le mur massif de texte, si tout cela n'est pas nécessaire s'il vous plaît laissez-moi savoir et je vais l'enlever!

Answer 1

Vos fichiers sources redéfinissent chaque classe; ils ne devraient pas faire ça. Au lieu de cela, ils doivent inclure l'en-tête qui définit la classe, puis définir chaque fonction déclarée dans la classe. Par exemple:

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

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