c errors undefined reference
wachtwoordcracker-software voor Windows 7
Deze tutorial beschrijft de kritieke fouten die programmeurs vaak tegenkomen in C ++, zoals ongedefinieerde referentie, een segmentatiefout (kern gedumpt) en onopgelost extern symbool:
We zullen de belangrijkste fouten bespreken die we vaak tegenkomen in C ++ die inderdaad even kritisch zijn. Afgezien van de systeem- en semantische fouten en uitzonderingen die van tijd tot tijd optreden, krijgen we ook andere kritieke fouten die de werking van programma's beïnvloeden.
Deze fouten treden meestal op tegen het einde van het programma tijdens runtime. Soms geeft het programma de juiste uitvoer en treedt de fout op.
Bezoek hier om C ++ vanaf het begin te leren.
Wat je leert:
Belangrijke C ++ -fouten
In deze tutorial zullen we drie soorten fouten bespreken die kritiek zijn vanuit het oogpunt van elke C ++ programmeur.
- Ongedefinieerde referentie
- Segmentatiefout (kern gedumpt)
- Onopgelost extern symbool
We zullen de mogelijke oorzaken van elk van deze fouten bespreken en samen met de voorzorgsmaatregelen die we als programmeur kunnen nemen om deze fouten te voorkomen.
Laten we beginnen!!
Ongedefinieerde referentie
Een 'Ongedefinieerde verwijzing' -fout treedt op wanneer we een verwijzing naar de objectnaam (klasse, functie, variabele, etc.) in ons programma hebben en de linker de definitie ervan niet kan vinden wanneer hij ernaar probeert te zoeken in alle gekoppelde objectbestanden en bibliotheken .
Dus wanneer de linker de definitie van een gekoppeld object niet kan vinden, geeft het een 'ongedefinieerde referentie' foutmelding. Zoals uit de definitie duidelijk blijkt, treedt deze fout op in de latere stadia van het koppelingsproces. Er zijn verschillende redenen die een 'ongedefinieerde referentie' -fout veroorzaken.
We bespreken hieronder enkele van deze redenen:
# 1) Geen definitie voor object
Dit is de eenvoudigste reden voor het veroorzaken van een 'ongedefinieerde referentie' -fout. De programmeur is gewoon vergeten het object te definiëren.
Beschouw het volgende C ++ -programma. Hier hebben we alleen het prototype van de functie gespecificeerd en deze vervolgens in de hoofdfunctie gebruikt.
Uitgang:
Dus wanneer we dit programma compileren, wordt de linkerfout uitgegeven met de tekst 'ongedefinieerde verwijzing naar‘ func1 () ’.
Om van deze fout af te komen, corrigeren we het programma als volgt door de definitie van de functie func1. Nu geeft het programma de juiste output.
Uitgang:
Hallo Wereld!!
# 2) Verkeerde definitie (handtekeningen komen niet overeen) van gebruikte objecten
Nog een andere oorzaak van de 'ongedefinieerde referentie' -fout is wanneer we verkeerde definities specificeren. We gebruiken elk object in ons programma en de definitie is iets anders.
Beschouw het volgende C ++ -programma. Hier hebben we een oproep gedaan naar func1 (). Het prototype is int func1 (). Maar de definitie komt niet overeen met het prototype. Zoals we zien, bevat de definitie van de functie een parameter voor de functie.
Dus wanneer het programma is gecompileerd, is de compilatie succesvol vanwege de overeenkomst tussen prototype en functieaanroep. Maar wanneer de linker probeert de functieaanroep aan zijn definitie te koppelen, vindt hij het probleem en geeft de foutmelding als 'ongedefinieerde referentie'.
Uitgang:
Om dergelijke fouten te voorkomen, controleren we eenvoudigweg of de definities en het gebruik van alle objecten in ons programma overeenkomen.
# 3) Objectbestanden zijn niet correct gekoppeld
Dit probleem kan ook aanleiding geven tot de fout 'ongedefinieerde referentie'. Hier hebben we mogelijk meer dan één bronbestand en kunnen we deze onafhankelijk compileren. Wanneer dit is gebeurd, zijn de objecten niet goed gekoppeld en resulteert dit in 'ongedefinieerde referentie'.
Beschouw de volgende twee C ++ -programma's. In het eerste bestand maken we gebruik van de “print ()” functie die in het tweede bestand is gedefinieerd. Wanneer we deze bestanden afzonderlijk compileren, geeft het eerste bestand 'ongedefinieerde referentie' voor de afdrukfunctie, terwijl het tweede bestand 'ongedefinieerde referentie' geeft voor de hoofdfunctie.
Uitgang:
Uitgang:
De manier om deze fout op te lossen, is door beide bestanden tegelijkertijd te compileren ( Bijvoorbeeld, door g ++ te gebruiken).
Afgezien van de reeds besproken oorzaken, kan 'ongedefinieerde verwijzing' ook optreden vanwege de volgende redenen.
# 4) Verkeerd projecttype
Als we verkeerde projecttypen specificeren in C ++ IDE's zoals de visuele studio en dingen proberen te doen die het project niet verwacht, dan krijgen we 'ongedefinieerde referentie'.
# 5) Geen bibliotheek
Als een programmeur het bibliotheekpad niet correct heeft gespecificeerd of helemaal vergeten is het te specificeren, dan krijgen we een 'ongedefinieerde referentie' voor alle referenties die het programma uit de bibliotheek gebruikt.
# 6) Afhankelijke bestanden worden niet gecompileerd
Een programmeur moet ervoor zorgen dat we van tevoren alle afhankelijkheden van het project compileren, zodat wanneer we het project compileren, de compiler alle afhankelijkheden vindt en met succes compileert. Als een van de afhankelijkheden ontbreekt, geeft de compiler 'ongedefinieerde referentie'.
Afgezien van de hierboven besproken oorzaken, kan de fout 'ongedefinieerde referentie' in veel andere situaties optreden. Maar het komt erop neer dat de programmeur de dingen verkeerd heeft en om deze fout te voorkomen, moeten ze worden gecorrigeerd.
world of warcraft beste privéserver
Segmentatiefout (kern gedumpt)
De fout 'segmentatiefout (kern gedumpt)' is een fout die duidt op geheugenbeschadiging. Het treedt meestal op wanneer we proberen toegang te krijgen tot een geheugen dat niet tot het betreffende programma behoort.
Hier zijn enkele van de redenen die een Segmentation-fout veroorzaken.
# 1) De constante reeks wijzigen
Beschouw het volgende programma waarin we een constante string hebben verklaard. Vervolgens proberen we deze constante reeks te wijzigen. Wanneer het programma wordt uitgevoerd, krijgen we de foutmelding die in de uitvoer wordt weergegeven.
Uitgang:
# 2) Dereferentie-aanwijzer
Een pointer moet naar een geldige geheugenlocatie wijzen voordat we de verwijzing ervan ongedaan maken. In het onderstaande programma zien we dat de pointer naar NULL wijst, wat betekent dat de geheugenlocatie waarnaar hij verwijst 0 is, d.w.z. ongeldig.
Dus als we het in de volgende regel verwijderen, proberen we in feite toegang te krijgen tot de onbekende geheugenlocatie. Dit resulteert inderdaad in een segmentatiefout.
Uitgang:
segmentatie fout
Het volgende programma toont een soortgelijk geval. Ook in dit programma wijst de aanwijzer niet naar geldige gegevens. Een niet-geïnitialiseerde aanwijzer is zo goed als NULL en wijst daarom ook naar een onbekende geheugenlocatie. Dus als we proberen de referentie ervan te herleiden, resulteert dit in een segmentatiefout.
Uitgang:
segmentatie fout
Om dergelijke fouten te voorkomen, moeten we ervoor zorgen dat onze pointervariabelen in het programma altijd naar geldige geheugenlocaties verwijzen.
# 3) Stack Overflow
Als we recursieve aanroepen in ons programma hebben, nemen ze al het geheugen in de stapel op en zorgen ervoor dat de stapel overloopt. In dergelijke gevallen krijgen we de segmentatiefout omdat een tekort aan stapelgeheugen ook een soort geheugenbeschadiging is.
Beschouw het onderstaande programma waarin we de faculteit van een getal recursief berekenen. Merk op dat onze basisvoorwaarde test of het getal 0 is en dan 1 retourneert. Dit programma werkt perfect voor positieve getallen.
Maar wat gebeurt er als we een negatief getal daadwerkelijk doorgeven aan een faculteit? Omdat de basisvoorwaarde niet wordt gegeven voor de negatieve getallen, weet de functie niet waar te stoppen en resulteert dit in een stack-overflow.
Dit wordt weergegeven in de onderstaande uitvoer die een segmentatiefout geeft.
Uitgang:
Segmentatiefout (kern gedumpt)
Om deze fout nu op te lossen, wijzigen we de basisvoorwaarde enigszins en specificeren we ook het geval voor negatieve getallen, zoals hieronder wordt weergegeven.
Uitgang:
Factoriële output: 1
Nu zien we dat de segmentatiefout is verholpen en dat het programma prima werkt.
Onopgelost extern symbool
Het onopgeloste externe symbool is een linkerfout die aangeeft dat het symbool of de referentie ervan niet kan worden gevonden tijdens het koppelingsproces. De fout is vergelijkbaar met 'ongedefinieerde referentie' en wordt door elkaar weergegeven.
hoe je een uitvoerbaar jar-bestand opent
We hebben hieronder twee gevallen gegeven waarin deze fout kan optreden.
# 1) Wanneer we verwijzen naar een structuurvariabele in het programma die een statisch lid bevat.
Uitgang:
In het bovenstaande programma heeft structuur C een statisch lid dat niet toegankelijk is voor de externe programma's. Dus wanneer we proberen het een waarde toe te kennen in de hoofdfunctie, vindt de linker het symbool niet en kan dit resulteren in een 'onopgelost extern symbool' of 'ongedefinieerde verwijzing'.
De manier om deze fout op te lossen, is door de variabele expliciet in een bereik te plaatsen met ‘::’ buiten de main voordat u deze gebruikt.
# 2) Als we externe variabelen hebben waarnaar wordt verwezen in het bronbestand, en we de bestanden die deze externe variabelen definiëren niet hebben gekoppeld.
Dit geval wordt hieronder gedemonstreerd:
Uitgang:
In het algemeen, in het geval van een 'onopgelost extern symbool', kan de gecompileerde code voor een objectachtige functie geen symbool vinden waarnaar het verwijst, misschien omdat dat symbool niet is gedefinieerd in de objectbestanden of in een van de bibliotheken gespecificeerd aan de linker.
Gevolgtrekking
In deze zelfstudie hebben we enkele belangrijke fouten in C ++ besproken die kritiek zijn en de programmastroom kunnen beïnvloeden en zelfs kunnen resulteren in een applicatiecrash. We hebben alles over Segmentatiefout, Onopgelost extern symbool en Ongedefinieerde referentie in detail onderzocht.
Hoewel deze fouten op elk moment kunnen optreden, weten we van de oorzaken die we hebben besproken dat we ze gemakkelijk kunnen voorkomen door ons programma zorgvuldig te ontwikkelen.
Lees de Easy C ++ Training Series door.