c errors undefined reference
beste Handy-Spyware für iPhone
In diesem Lernprogramm werden die kritischen Fehler beschrieben, auf die Programmierer in C ++ häufig stoßen, z. B. Undefinierte Referenz, Segmentierungsfehler (Core Dump) und ungelöstes externes Symbol:
Wir werden die wichtigsten Fehler diskutieren, die in C ++ häufig auftreten und die in der Tat gleichermaßen kritisch sind. Neben den System- und semantischen Fehlern und Ausnahmen, die von Zeit zu Zeit auftreten, treten auch andere kritische Fehler auf, die sich auf die Ausführung von Programmen auswirken.
Diese Fehler treten meist gegen Ende des Programms zur Laufzeit auf. Manchmal gibt das Programm die richtige Ausgabe aus und dann tritt der Fehler auf.
=> Besuchen Sie hier, um C ++ von Grund auf neu zu lernen.
Was du lernen wirst:
Wichtige C ++ - Fehler
In diesem Tutorial werden drei Arten von Fehlern erläutert, die aus Sicht eines C ++ - Programmierers kritisch sind.
- Undefinierte Referenz
- Segmentierungsfehler (Core Dumped)
- Ungelöstes externes Symbol
Wir werden die möglichen Ursachen für jeden dieser Fehler und die Vorsichtsmaßnahmen erörtern, die wir als Programmierer treffen können, um diese Fehler zu vermeiden.
Lasst uns beginnen!!
Undefinierte Referenz
Ein Fehler 'Undefinierte Referenz' tritt auf, wenn wir in unserem Programm einen Verweis auf den Objektnamen (Klasse, Funktion, Variable usw.) haben und der Linker seine Definition nicht finden kann, wenn er versucht, in allen verknüpften Objektdateien und Bibliotheken danach zu suchen .
Wenn der Linker die Definition eines verknüpften Objekts nicht finden kann, gibt er einen Fehler 'undefinierte Referenz' aus. Wie aus der Definition hervorgeht, tritt dieser Fehler in den späteren Phasen des Verknüpfungsprozesses auf. Es gibt verschiedene Gründe, die einen Fehler 'undefinierte Referenz' verursachen.
Wir diskutieren einige dieser Gründe unten:
# 1) Keine Definition für Objekt vorgesehen
Dies ist der einfachste Grund, einen Fehler 'undefinierte Referenz' zu verursachen. Der Programmierer hat einfach vergessen, das Objekt zu definieren.
Betrachten Sie das folgende C ++ - Programm. Hier haben wir nur den Funktionsprototyp spezifiziert und ihn dann in der Hauptfunktion verwendet.
#include int func1(); int main() { func1(); }Ausgabe:
Wenn wir dieses Programm kompilieren, wird der Linker-Fehler ausgegeben, der 'undefinierter Verweis auf' func1 () 'besagt.
Um diesen Fehler zu beseitigen, korrigieren wir das Programm wie folgt, indem wir die Definition der Funktion func1 angeben. Jetzt gibt das Programm die entsprechende Ausgabe.
#include using namespace std; int func1(); int main() { func1(); } int func1(){ cout<<'hello, world!!'; }Ausgabe:
Hallo Welt!!
# 2) Falsche Definition (Signaturen stimmen nicht überein) der verwendeten Objekte
Eine weitere Ursache für den Fehler 'undefinierte Referenz' ist die Angabe falscher Definitionen. Wir verwenden jedes Objekt in unserem Programm und seine Definition ist etwas anderes.
Betrachten Sie das folgende C ++ - Programm. Hier haben wir func1 () angerufen. Sein Prototyp ist int func1 (). Die Definition stimmt jedoch nicht mit dem Prototyp überein. Wie wir sehen, enthält die Definition der Funktion einen Parameter für die Funktion.
Wenn das Programm kompiliert wird, ist die Kompilierung aufgrund der Übereinstimmung von Prototyp und Funktionsaufruf erfolgreich. Wenn der Linker jedoch versucht, den Funktionsaufruf mit seiner Definition zu verknüpfen, findet er das Problem und gibt den Fehler als 'undefinierte Referenz' aus.
#include using namespace std; int func1(); int main() { func1(); } int func1(int n){ cout<<'hello, world!!'; }Ausgabe:
Um solche Fehler zu vermeiden, überprüfen wir einfach, ob die Definitionen und die Verwendung aller Objekte in unserem Programm übereinstimmen.
# 3) Objektdateien nicht richtig verknüpft
Dieses Problem kann auch zu dem Fehler 'undefinierte Referenz' führen. Hier haben wir möglicherweise mehr als eine Quelldatei und können diese unabhängig kompilieren. Wenn dies erledigt ist, werden die Objekte nicht richtig verknüpft und es entsteht eine „undefinierte Referenz“.
Betrachten Sie die folgenden zwei C ++ - Programme. In der ersten Datei verwenden wir die Funktion 'print ()', die in der zweiten Datei definiert ist. Wenn wir diese Dateien separat kompilieren, gibt die erste Datei 'undefinierte Referenz' für die Druckfunktion an, während die zweite Datei 'undefinierte Referenz' für die Hauptfunktion enthält.
int print(); int main() { print(); }Ausgabe:
int print() { return 42; }Ausgabe:
Die Möglichkeit, diesen Fehler zu beheben, besteht darin, beide Dateien gleichzeitig zu kompilieren ( Beispielsweise, mit g ++).
Abgesehen von den bereits diskutierten Ursachen kann aus den folgenden Gründen auch eine „undefinierte Referenz“ auftreten.
# 4) Falscher Projekttyp
Wenn wir in C ++ - IDEs wie dem Visual Studio falsche Projekttypen angeben und versuchen, Dinge zu tun, die das Projekt nicht erwartet, erhalten wir eine „undefinierte Referenz“.
# 5) Keine Bibliothek
Wenn ein Programmierer den Bibliothekspfad nicht richtig angegeben oder vollständig vergessen hat, ihn anzugeben, erhalten wir eine „undefinierte Referenz“ für alle vom Programm verwendeten Referenzen aus der Bibliothek.
# 6) Abhängige Dateien werden nicht kompiliert
Ein Programmierer muss sicherstellen, dass wir alle Abhängigkeiten des Projekts im Voraus kompilieren, damit der Compiler beim Kompilieren des Projekts alle Abhängigkeiten findet und erfolgreich kompiliert. Wenn eine der Abhängigkeiten fehlt, gibt der Compiler eine „undefinierte Referenz“ an.
Abgesehen von den oben diskutierten Ursachen kann der Fehler 'undefinierte Referenz' in vielen anderen Situationen auftreten. Aber das Fazit ist, dass der Programmierer die Dinge falsch gemacht hat und um diesen Fehler zu verhindern, sollten sie korrigiert werden.
wie man einen Testplan schreibt
Segmentierungsfehler (Core Dumped)
Der Fehler 'Segmentierungsfehler (Core Dumped)' ist ein Fehler, der auf eine Speicherbeschädigung hinweist. Es tritt normalerweise auf, wenn wir versuchen, auf einen Speicher zuzugreifen, der nicht zum betrachteten Programm gehört.
Hier sind einige der Gründe, die einen Segmentierungsfehler verursachen.
# 1) Ändern der konstanten Zeichenfolge
Betrachten Sie das folgende Programm, in dem wir eine konstante Zeichenfolge deklariert haben. Dann versuchen wir, diese konstante Zeichenfolge zu ändern. Wenn das Programm ausgeführt wird, wird der in der Ausgabe angezeigte Fehler angezeigt.
#include int main() { char *str; //constant string str = 'STH'; //modifying constant string *(str+1) = 'c'; return 0; } Ausgabe:
# 2) Dereferenzierungszeiger
Ein Zeiger muss auf einen gültigen Speicherort zeigen, bevor wir ihn dereferenzieren. Im folgenden Programm sehen wir, dass der Zeiger auf NULL zeigt, was bedeutet, dass der Speicherort, auf den er zeigt, 0 ist, d. H. Ungültig.
Wenn wir es also in der nächsten Zeile dereferenzieren, versuchen wir tatsächlich, auf seinen unbekannten Speicherort zuzugreifen. Dies führt tatsächlich zu einem Segmentierungsfehler.
#include using namespace std; int main() { int* ptr = NULL; //here we are accessing unknown memory location *ptr = 1; cout << *ptr; return 0; } Ausgabe:
Segmentierungsfehler
Das nächste Programm zeigt einen ähnlichen Fall. Auch in diesem Programm zeigt der Zeiger nicht auf gültige Daten. Ein nicht initialisierter Zeiger ist so gut wie NULL und zeigt daher auch auf einen unbekannten Speicherort. Wenn wir also versuchen, es zu dereferenzieren, führt dies zu einem Segmentierungsfehler.
#include using namespace std; int main() { int *p; cout<<*p; return 0; } Ausgabe:
Segmentierungsfehler
Um solche Fehler zu vermeiden, müssen wir sicherstellen, dass unsere Zeigervariablen im Programm immer auf gültige Speicherstellen verweisen.
# 3) Stapelüberlauf
Wenn wir rekursive Aufrufe in unserem Programm haben, verbrauchen sie den gesamten Speicher im Stapel und verursachen einen Überlauf des Stapels. In solchen Fällen tritt der Segmentierungsfehler auf, da der Mangel an Stapelspeicher auch eine Art Speicherbeschädigung darstellt.
Betrachten Sie das folgende Programm, in dem wir die Fakultät einer Zahl rekursiv berechnen. Beachten Sie, dass unsere Grundbedingung prüft, ob die Zahl 0 ist und dann 1 zurückgibt. Dieses Programm funktioniert perfekt für positive Zahlen.
Aber was passiert, wenn wir tatsächlich eine negative Zahl an eine Fakultätsfunktion übergeben? Nun, da die Grundbedingung für die negativen Zahlen nicht angegeben ist, weiß die Funktion nicht, wo sie aufhören soll, und führt somit zu einem Stapelüberlauf.
Dies wird in der folgenden Ausgabe gezeigt, die einen Segmentierungsfehler ergibt.
#include using namespace std; int factorial(int n) { if(n == 0) { return 1; } return factorial(n-1) * n; } int main() { cout< Ausgabe:
Segmentierungsfehler (Core Dumped)
Um diesen Fehler zu beheben, ändern wir nun die Grundbedingung geringfügig und geben auch den Fall für negative Zahlen an, wie unten gezeigt.
#include using namespace std; int factorial(int n) { // What about n <0? if(n <= 0) { return 1; } return factorial(n-1) * n; } int main() { cout<<'Factorial output:'< Ausgabe:
Faktorielle Ausgabe: 1
Jetzt sehen wir, dass der Segmentierungsfehler behoben ist und das Programm einwandfrei funktioniert.
Ungelöstes externes Symbol
Das nicht aufgelöste externe Symbol ist ein Linkerfehler, der angibt, dass das Symbol oder seine Referenz während des Verknüpfungsprozesses nicht gefunden werden kann. Der Fehler ähnelt der 'undefinierten Referenz' und wird austauschbar ausgegeben.
Wir haben unten zwei Fälle angegeben, in denen dieser Fehler auftreten kann.
# 1) Wenn wir auf eine Strukturvariable im Programm verweisen, die ein statisches Element enthält.
#include struct C { static int s; }; // int C::s; // Uncomment the following line to fix the error. int main() { C c; C::s = 1; } Ausgabe:
In dem obigen Programm hat Struktur C ein statisches Element, auf das die externen Programme nicht zugreifen können. Wenn wir also versuchen, ihm einen Wert in der Hauptfunktion zuzuweisen, findet der Linker das Symbol nicht und kann zu einem 'ungelösten externen Symbol' oder einer 'undefinierten Referenz' führen.
Die Möglichkeit, diesen Fehler zu beheben, besteht darin, die Variable vor der Verwendung explizit mit '::' außerhalb des Hauptbereichs zu erfassen.
# 2) Wenn externe Variablen in der Quelldatei referenziert sind und wir die Dateien, die diese externen Variablen definieren, nicht verknüpft haben.
Dieser Fall wird unten gezeigt:
#include #include using namespace std; extern int i; extern void g(); void f() { i++; g(); } int main() {} Ausgabe:
Laufzeitpolymorphismus in c ++
Im Allgemeinen findet der kompilierte Code für eine objektähnliche Funktion im Fall eines „nicht aufgelösten externen Symbols“ kein Symbol, auf das er verweist, möglicherweise weil dieses Symbol nicht in den Objektdateien oder einer der Bibliotheken definiert ist dem Linker angegeben.
Fazit
In diesem Tutorial haben wir einige wichtige Fehler in C ++ besprochen, die kritisch sind und den Programmablauf beeinträchtigen können und sogar zu einem Anwendungsabsturz führen können. Wir haben alles über Segmentierungsfehler, ungelöste externe Symbole und undefinierte Referenzen im Detail untersucht.
Obwohl diese Fehler jederzeit auftreten können, wissen wir aus den von uns diskutierten Ursachen, dass wir sie leicht verhindern können, indem wir unser Programm sorgfältig entwickeln.
=> Lesen Sie die Easy C ++ - Schulungsserie durch.
Literatur-Empfehlungen
