c errors undefined reference
logiciel pour copier un dvd sur un ordinateur
Ce didacticiel détaille les erreurs critiques que les programmeurs rencontrent souvent en C ++ comme une référence non définie, une erreur de segmentation (core dumped) et un symbole externe non résolu:
Nous discuterons des erreurs les plus importantes que nous rencontrons souvent en C ++ et qui sont tout aussi critiques. Outre les erreurs système et sémantiques et les exceptions qui se produisent de temps en temps, nous obtenons également d'autres erreurs critiques qui affectent l'exécution des programmes.
Ces erreurs se produisent principalement vers la fin du programme au moment de l'exécution. Parfois, le programme donne une sortie correcte, puis l'erreur se produit.
=> Visitez ici pour apprendre le C ++ à partir de zéro.
Ce que vous apprendrez:
Erreurs C ++ importantes
Dans ce didacticiel, nous aborderons trois types d’erreurs critiques du point de vue de tout programmeur C ++.
- Référence indéfinie
- Segmentation fault (core dumped)
- Symbole externe non résolu
Nous discuterons des causes possibles de chacune de ces erreurs et des précautions que nous pouvons prendre en tant que programmeur pour éviter ces erreurs.
Commençons!!
Référence indéfinie
Une erreur «Référence indéfinie» se produit lorsque nous avons une référence au nom de l'objet (classe, fonction, variable, etc.) dans notre programme et que l'éditeur de liens ne peut pas trouver sa définition lorsqu'il essaie de le rechercher dans tous les fichiers d'objets et bibliothèques liés .
Ainsi, lorsque l'éditeur de liens ne peut pas trouver la définition d'un objet lié, il émet une erreur de «référence indéfinie». Comme il ressort de la définition, cette erreur se produit dans les dernières étapes du processus de liaison. Il existe diverses raisons qui provoquent une erreur de «référence indéfinie».
Nous discutons de certaines de ces raisons ci-dessous:
# 1) Aucune définition fournie pour l'objet
C'est la raison la plus simple pour provoquer une erreur de «référence indéfinie». Le programmeur a simplement oublié de définir l'objet.
Considérez le programme C ++ suivant. Ici, nous avons seulement spécifié le prototype de fonction et l'avons ensuite utilisé dans la fonction principale.
#include int func1(); int main() { func1(); }Production:
Ainsi, lorsque nous compilons ce programme, l'erreur de l'éditeur de liens qui dit «référence indéfinie à« func1 () »» est émise.
Afin de se débarrasser de cette erreur, nous corrigeons le programme comme suit en fournissant la définition de la fonction func1. Maintenant, le programme donne la sortie appropriée.
#include using namespace std; int func1(); int main() { func1(); } int func1(){ cout<<'hello, world!!'; }Production:
Bonjour le monde!!
# 2) Mauvaise définition (les signatures ne correspondent pas) des objets utilisés
Une autre cause d'erreur de «référence indéfinie» est lorsque nous spécifions des définitions erronées. Nous utilisons n'importe quel objet dans notre programme et sa définition est différente.
Considérez le programme C ++ suivant. Ici, nous avons fait un appel à func1 (). Son prototype est int func1 (). Mais sa définition ne correspond pas à son prototype. Comme nous le voyons, la définition de la fonction contient un paramètre de la fonction.
Ainsi, lorsque le programme est compilé, la compilation réussit en raison de la correspondance entre le prototype et l'appel de fonction. Mais lorsque l'éditeur de liens essaie de lier l'appel de fonction à sa définition, il trouve le problème et émet l'erreur en tant que «référence non définie».
#include using namespace std; int func1(); int main() { func1(); } int func1(int n){ cout<<'hello, world!!'; }Production:
Ainsi, pour éviter de telles erreurs, nous vérifions simplement si les définitions et l'utilisation de tous les objets correspondent dans notre programme.
# 3) Les fichiers d'objets ne sont pas liés correctement
Ce problème peut également donner lieu à l'erreur «référence indéfinie». Ici, nous pouvons avoir plus d'un fichier source et nous pouvons les compiler indépendamment. Lorsque cela est fait, les objets ne sont pas correctement liés et il en résulte une «référence non définie».
Considérez les deux programmes C ++ suivants. Dans le premier fichier, nous utilisons la fonction «print ()» qui est définie dans le second fichier. Lorsque nous compilons ces fichiers séparément, le premier fichier donne une «référence indéfinie» pour la fonction d'impression, tandis que le second fichier donne une «référence non définie» pour la fonction principale.
int print(); int main() { print(); }Production:
int print() { return 42; }Production:
La façon de résoudre cette erreur consiste à compiler les deux fichiers simultanément ( Par exemple, en utilisant g ++).
Outre les causes déjà évoquées, une «référence indéfinie» peut également se produire pour les raisons suivantes.
# 4) Type de projet incorrect
Lorsque nous spécifions des types de projets incorrects dans les IDE C ++ comme le studio visuel et que nous essayons de faire des choses auxquelles le projet ne s'attend pas, nous obtenons une «référence indéfinie».
# 5) Pas de bibliothèque
Si un programmeur n'a pas spécifié correctement le chemin de la bibliothèque ou a complètement oublié de le spécifier, alors nous obtenons une «référence non définie» pour toutes les références que le programme utilise à partir de la bibliothèque.
# 6) Les fichiers dépendants ne sont pas compilés
Un programmeur doit s'assurer que nous compilons toutes les dépendances du projet au préalable afin que lorsque nous compilons le projet, le compilateur trouve toutes les dépendances et compile avec succès. Si l'une des dépendances est manquante, le compilateur donne une «référence non définie».
Outre les causes évoquées ci-dessus, l'erreur «référence indéfinie» peut se produire dans de nombreuses autres situations. Mais l'essentiel est que le programmeur s'est trompé et que pour éviter cette erreur, ils doivent être corrigés.
mot de passe et nom d'utilisateur par défaut du routeur
Segmentation fault (core dumped)
L'erreur «erreur de segmentation (core dumped)» est une erreur qui indique une corruption de la mémoire. Cela se produit généralement lorsque nous essayons d'accéder à une mémoire qui n'appartient pas au programme en considération.
Voici quelques-unes des raisons qui provoquent une erreur de segmentation.
# 1) Modification de la chaîne constante
Considérez le programme suivant dans lequel nous avons déclaré une chaîne constante. Ensuite, nous essayons de modifier cette chaîne constante. Lorsque le programme est exécuté, nous obtenons l'erreur affichée dans la sortie.
#include int main() { char *str; //constant string str = 'STH'; //modifying constant string *(str+1) = 'c'; return 0; } Production:
# 2) Pointeur de déréférencement
Un pointeur doit pointer vers un emplacement mémoire valide avant de le déréférencer. Dans le programme ci-dessous, nous voyons que le pointeur pointe vers NULL, ce qui signifie que l'emplacement mémoire vers lequel il pointe est 0, c'est-à-dire invalide.
Par conséquent, lorsque nous le déréférencons dans la ligne suivante, nous essayons en fait d'accéder à son emplacement mémoire inconnu. Il en résulte en effet un défaut de segmentation.
#include using namespace std; int main() { int* ptr = NULL; //here we are accessing unknown memory location *ptr = 1; cout << *ptr; return 0; } Production:
Défaut de segmentation
Le programme suivant montre un cas similaire. Dans ce programme également, le pointeur ne pointe pas vers des données valides. Un pointeur non initialisé est aussi bon que NULL et par conséquent, il pointe également vers un emplacement mémoire inconnu. Ainsi, lorsque nous essayons de le déréférencer, il en résulte un défaut de segmentation.
#include using namespace std; int main() { int *p; cout<<*p; return 0; } Production:
Défaut de segmentation
Afin d'éviter de telles erreurs, nous devons nous assurer que nos variables de pointeur dans le programme pointent toujours vers des emplacements de mémoire valides.
# 3) Débordement de pile
meilleurs serveurs pour jouer sur wow
Lorsque nous avons des appels récursifs dans notre programme, ils consomment toute la mémoire de la pile et provoquent un débordement de la pile. Dans de tels cas, nous obtenons l'erreur de segmentation car manquer de mémoire de la pile est également une sorte de corruption de la mémoire.
Considérez le programme ci-dessous où nous calculons la factorielle d'un nombre récursivement. Notez que notre condition de base teste si le nombre est 0 puis renvoie 1. Ce programme fonctionne parfaitement pour les nombres positifs.
Mais que se passe-t-il lorsque nous passons réellement un nombre négatif à une fonction factorielle? Eh bien, comme la condition de base n'est pas donnée pour les nombres négatifs, la fonction ne sait pas où s'arrêter et entraîne donc un débordement de pile.
Ceci est indiqué dans la sortie ci-dessous qui donne un défaut de segmentation.
#include using namespace std; int factorial(int n) { if(n == 0) { return 1; } return factorial(n-1) * n; } int main() { cout< Production:
Segmentation fault (core dumped)
Maintenant, pour corriger cette erreur, nous modifions légèrement la condition de base et spécifions également le cas des nombres négatifs comme indiqué ci-dessous.
#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:'< Production:
Sortie factorielle: 1
Nous voyons maintenant que l'erreur de segmentation est prise en charge et que le programme fonctionne correctement.
Symbole externe non résolu
Le symbole externe non résolu est une erreur de l'éditeur de liens qui indique qu'il ne peut pas trouver le symbole ou sa référence pendant le processus de liaison. L'erreur est similaire à «référence indéfinie» et est émise de manière interchangeable.
Nous avons donné ci-dessous deux exemples où cette erreur peut se produire.
# 1) Lorsque nous référons une variable de structure dans le programme qui contient un membre statique.
#include struct C { static int s; }; // int C::s; // Uncomment the following line to fix the error. int main() { C c; C::s = 1; } Production:
Dans le programme ci-dessus, la structure C a un membre statique qui n'est pas accessible aux programmes extérieurs. Ainsi, lorsque nous essayons de lui attribuer une valeur dans la fonction principale, l'éditeur de liens ne trouve pas le symbole et peut entraîner un «symbole externe non résolu» ou une «référence non définie».
Le moyen de corriger cette erreur est de définir explicitement la variable en utilisant ‘::’ en dehors de main avant de l’utiliser.
# 2) Lorsque nous avons des variables externes référencées dans le fichier source, et que nous n'avons pas lié les fichiers qui définissent ces variables externes.
Ce cas est illustré ci-dessous:
#include #include using namespace std; extern int i; extern void g(); void f() { i++; g(); } int main() {} Production:
En général, dans le cas d'un «symbole externe non résolu», le code compilé pour tout objet comme une fonction ne parvient pas à trouver un symbole auquel il fait référence, peut-être parce que ce symbole n'est pas défini dans les fichiers objets ou dans l'une des bibliothèques spécifié à l'éditeur de liens.
Conclusion
Dans ce didacticiel, nous avons discuté de certaines erreurs majeures en C ++ qui sont critiques et peuvent affecter le flux du programme et peuvent même entraîner un blocage de l'application. Nous avons exploré en détail tout ce qui concerne les erreurs de segmentation, les symboles externes non résolus et les références non définies.
Bien que ces erreurs puissent survenir à tout moment, à partir des causes dont nous avons discuté, nous savons que nous pouvons facilement les éviter en développant soigneusement notre programme.
=> Lisez la série de formations Easy C ++.
lecture recommandée
