幫助器了解鏈接器錯誤LNK2019

Question

我知道這里有很多與此主題有關的問題，但是我在代碼中找不到未引用的符號。

這是錯誤：

錯誤LNK2019：未解析的外部符號“ public：__thiscall MyString :: MyString（char const *）”（?? 0MyString @@ QAE @ PBD @ Z）在函數“ public：__thiscall Fahrzeug :: Fahrzeug（char *）”中引用（？ 0Fahrzeug @@ QAE @ PAD @ Z）

這是創建的字符串類的標題：

#ifndef MyString_h
#define MyString_h

#include <ostream>

using namespace std;


class MyString{

    char *strPtr=nullptr;
    unsigned int strSize;
    unsigned int strCapacity;
public:
    //Standardkonstruktor
    MyString();
    //Konvertierkonstruktor
    MyString(const char *);
    //Kopierkonstruktor
    MyString(const MyString&);
    //Destruktor
    ~MyString();


    void reserve(unsigned int c);
    MyString & append(MyString & );
    MyString & assign(MyString & );

    unsigned int size();
    unsigned int capacity();
    void clear();
    bool empty();
    const char* c_str();

    char  &at( int);

    MyString operator+( MyString &);
    bool operator==(const MyString &);
    MyString operator=(MyString &);
    friend ostream & operator<<(ostream &, MyString);
};

//MyString operator+(const MyString &);
//MyString operator==(const MyString &, const MyString &);
//MyString operator[]( MyString &);
//MyString operator<<(const MyString &);

#endif

這是mystring類的cpp文件

    #include "MyString.hpp"
    #include <ostream>
    using namespace std;
    #include <cstring>



    //Hausaufgabe 2 Eigene String Klasse Teil 1

    //Standardkonstruktor legt leeren String an 
    MyString::MyString()
    :strCapacity(1), strSize(0)
    {

        this->strPtr = new char[strCapacity];
        /*this->strPtr[0] = "\0";*/
    }


    // Konvertierkonstruktor wandelt C-String in MyString um
    MyString::MyString(const char  * string){

        //größe String herausfinden
        unsigned int i = strlen(string);
        //Größe und Kapazität des Strings festlegen
        this->strCapacity = i;
        this->strSize = i;
        // Dynamisches Array Erzeugen. i+1 für abschließendes  "\0" Zeichen
        this->strPtr = new char[i+1];
        //string in strPtr kopieren
        strncpy(this->strPtr, string, i);

        //Abschließendes "\0" Zeichen einfügen
        this->strPtr[i] = '\0';
    }

    MyString::MyString( const MyString & old){
        //Tiefe Kopie von old anlegen
        int size = int(strlen(old.strPtr));
        strPtr = new char[size];  
        strncpy(strPtr, old.strPtr, old.strSize);
        this->strSize = int(strlen(old.strPtr));
        this->strCapacity = old.strCapacity;
        this->strPtr[this->strSize] = '\0';
    }

    MyString::~MyString(){
        // Freigegebener Speicher wird wieder gelöscht
        delete[] this->strPtr;
        strPtr = nullptr;
    }

    void MyString::reserve(unsigned int c){
        //prüfen ob Speicherplatz benötigt wird

            //reservespeicher wird angelegt und String wird gesichert
            char *temp = new char[this->strSize];
            strncpy(temp,this->strPtr,this->strSize) ;
            //Destruktor zum löschen des freigegebenen Speichers wird aufgerufen
            delete[] strPtr;
            //Speicher mit erhöhter Kapazität wird angefordert
            this->strPtr = new char[sizeof(char)*(c+1)];
            //Gesicherter String auf neuen Speicher übertragen und "\0" wird eingefügt
            strncpy(this->strPtr, temp, this->strSize);
            /*this->strPtr[c+1] = '\0';*/
            //temp wird wieder gelöscht
            delete[] temp;

    }
    //Gibt den C-String zurück
    const char*  MyString::c_str(){

        return strPtr;
    }
    //gibt größe des Strings ohne abhließendes 0-Zeichen zurück
    unsigned int MyString::size(){
        return this->strSize;

    }
    //Leert den String
    void MyString::clear(){
        for (int i = 0; i < this->strCapacity; i++) {
            this->strPtr[i] = 0;
        }

    }
    //Hängt Strings aneinander
    MyString & MyString::append(MyString &str){
        // Ermittelt Größe des neuen Strings
        unsigned int newSize = this->strSize+str.strSize;
        //Größe und Kapazität des Strings werden aktualisiert
        this->strSize = newSize;
        this->strCapacity = newSize;
        //vergrößert den Speicher für den neuen String
        this->reserve(newSize);
        //Fügt die Strings zusammen 
        strcat(this->strPtr,str.strPtr);
        //abschließendes 0-Zeichen
        this->strPtr[this->strSize] = '\0';
        return str;
    }
    //Überschreibt String mit neuen Chars
    MyString & MyString::assign(MyString &str){
        //prüft ob neuer Speicher beschafft werden soll 
        if (this->strSize < str.strSize){
            reserve(str.strSize);
            //fügt neuen String ein
            strncpy(this->strPtr, str.strPtr,str.strSize);
            //aktualisiert Größe und Kapazität des Strings
            this->strSize = str.size();
            this->strCapacity = str.capacity();
            //abschließendes 0-Zeichen
            this->strPtr[this->strSize] = '\0';
        }
        else{
            //falls Speicher nicht vergrößert werden muss 
            //wird string eingefügt
            strncpy(this->strPtr, str.strPtr, str.strSize);
        }
        return str;
    }
    //Gibt Kapazität zurück
    unsigned int MyString::capacity(){
        return this->strCapacity;
    }
    //prüft ob String leer ist 
    bool MyString::empty(){
        if (this->strSize = 0)
            return true;
    }
    //ersetzt Zeichen an der i-ten Stelle
    char &MyString::at( int i){
        if (i > this->strCapacity)
            return this->strPtr[0];
        else{
            return this->strPtr[i-1];
        }
    }

    //Hausaufgabe 3 Eigene String Klasse Teil 2 Operatoren

    MyString MyString::operator+( MyString & other){

        MyString neu(this->strPtr);

        neu.append(other);
        return neu;
    }
    bool  MyString::operator==(const MyString & compare){
        if (this->strSize == compare.strSize){
            for (int i = 0; (this->strPtr[i] && compare.strPtr[i]) != '\0'; i++){
                if (this->strPtr[i] != compare.strPtr[i]){
                    return 0;
                    break;
                }
                else return 1;


            }

        }

    }
    ostream &operator<< (ostream & push, MyString out){ 
        /*for (int i = 0; out.strPtr[i] != '\0'; i++){
            push << out.strPtr[i];
        }*/

        push << out.c_str();
        return push;

    }

    MyString  MyString::operator=(MyString & change){


        this->assign(change);
        return change;
    }

    //MyString  MyString::operator[](MyString & index){
    //
    //}

這是我將使用mystring類的程序

標頭：

#include"..\A3\A3\MyString.hpp"
#pragma once
class Fahrzeug{

private:
    MyString kz;
    /*static int vin;*/
    double km;
public:
    Fahrzeug( char *kfz);
    void fahren(double);
    /*friend ostream & operator<<(ostream &, Fahrzeug);*/
};

cpp文件：

#include "Fahrzeug.hpp"
#include"..\A3\A3\MyString.hpp"
#pragma once

Fahrzeug::Fahrzeug(char* kfz)
:kz(kfz)
{

}

void Fahrzeug::fahren(double km)
{

    this->km += km;
}
//ostream &operator<<(ostream& push, Fahrzeug out){
//  return push<<"KennZeichen: "<<out.kz<<endl<<"VIN: "/*<<out.vin*/<<endl<<"KM: "<<out.km<<endl;
//}

主程序：

#include "Fahrzeug.hpp"

#pragma once
#include <iostream>
using namespace std;

//int Fahrzeug::zaehler = 0;

int main() {
    Fahrzeug f1("ES - H 123");
    /*cout << f1 << endl;*/
    f1.fahren(101.5);
    /*cout << f1 << endl;*/
    Fahrzeug f2("ES - M 4711");
    f2.fahren(10.57);
    /*cout << f2 << endl;*/
    return 0;
}

Answer 1

那是鏈接錯誤。 這意味着編譯器可以找到該函數的原型，但是找不到該函數的實際定義。

在您的特定情況下，通過在Fahrezug類中創建kz變量，您調用了MyString類的構造函數，由於某種原因，鏈接器找不到該構造函數的定義。 我的猜測是，這是因為字符串類的標頭和字符串類的源文件是相同的，所以鏈接器會兩次看到構造函數的定義，並且不知道使用哪個（即使兩者相同，鏈接器不會檢查它，當看到相同功能的兩個定義時，它會給您一個錯誤，而無需進一步檢查。

如果您偶然粘貼了源代碼而不是標題，則可能是因為您忘記了將源文件包含在項目中（源文件必須位於IDE中的源文件列表中）。

我也建議使用

#ifndef MYHEADER_H
#define MYHEADER_H

在每個頭文件的開頭和#endif的末尾，以避免兩次包含相同的頭文件，因此會出現這種類型的錯誤。