Bonjour et bienvenue à nouveau.
Dans cette conférence, je veux parler de certaines erreurs courantes que vous ferez lors
de la programmation en c.
Certains d'entre eux vous sont peut-être familiers grâce à vos
défis précédents, et vous avez déjà rencontré ces erreurs, mais ce
sont les types d'erreurs les plus courants.
Le premier est très, très évident. Il manque un point-virgule.
N'oubliez pas que toutes les instructions de c se termineront par un point-virgule.
Si vous ne l'avez pas là, le compilateur va se plaindre.
Donc, soit égarer un point-virgule, soit manquer complètement un point-virgule est
une erreur très courante. Dans ce cas, nous perdons un point-virgule.
Nous avons une déclaration if. Nous mettons un point-virgule à la fin de l'instruction if.
Et cela fait en fait que le comportement du programme est complètement différent.
Cela compilera en fait.
Lorsque vous manquez un point-virgule et que vous ne l'avez même pas inclus, il ne se compilera pas.
Mais dans ce cas, la valeur de j sera toujours mise à zéro
car le point-virgule de l'instruction if a été placé.
Le point-virgule est donc parfaitement valide pour l'avoir après l'instruction if.
Il représente en fait l'instruction null.
Et par conséquent, vous n'avez pas d'erreur du
compilateur, mais cela posera un problème car j ne sera jamais mis à zéro.
Et ce type d'erreur peut également être courant en boucle.
Lorsque vous avez une boucle et que vous mettez le
point-virgule à la fin de la boucle for, vous pouvez avoir un crochet, où vous
n'avez pas le crochet car vous aurez une erreur si vous avez le crochet, très courant.
Un autre est de confondre l'opérateur égal avec l'opérateur égal égal à.
Spécifiquement mentionné que l'opérateur égal est égal à
ne pas comparer les chaînes. Donc, si vous utilisez égal à égal lorsque
vous comparez des chaînes, ce n'est pas valide. Il va simplement comparer les références.
Mais si vous voulez réellement attribuer une valeur à une variable et utiliser
à la place les égaux égaux, vous allez avoir un compilateur.
Maintenant, si vous essayez de comparer deux éléments, comme deux entiers
à l'intérieur d'une instruction if et que vous utilisez à la place
l'opérateur d'affectation, vous n'aurez en fait pas d'erreur
de compilation, mais cette expression sera toujours évaluée à true.
Ainsi, lorsque vous utilisez les égaux et que vous n'utilisez pas
les égaux, cela est généralement fait dans l'instruction if while do, à l'intérieur de l'expression booléenne.
Et ceci est valable sauf que cela
a pour effet d'assigner quelque chose plutôt que d'exécuter quelque chose.
Donc, dans cet exemple,
si nous avons si a est égal à 2, il attribue 2 à a.
Il est toujours défini sur true car c'est une déclaration vraie, car vous n'échouez
jamais lorsque vous effectuez une affectation. Et donc printf fonctionnera toujours.
Ce que vous vouliez vraiment faire ici, c'est dire si a est égal à.
Il est donc très courant d'utiliser les égaux par opposition aux égaux égaux
et ne pas avoir d'erreur de compilation.
Si vous utilisez égal à égal dans la
mauvaise situation, vous pouvez également
avoir un comportement inattendu, mais vous aurez une
erreur du compilateur si vous l'utilisez de manière incorrecte pour l'affectation.
Mais faites attention à cela avec les égaux au lieu des égaux égaux.
Omettre les déclarations de prototype.
J'ai mentionné qu'il est vraiment important de toujours déclarer vos fonctions
en haut du fichier avant de les utiliser.
Cependant, cela ne se produit pas toujours et c'est une erreur très courante.
Et généralement, vous obtiendrez une erreur de déclaration implicite dans
le compilateur.
Dans cet exemple, si vous avez défini la racine carrée plus tard
dans le programme que là où vous l'appelez ou dans un autre
fichier et que vous ne l'avez
pas explicitement déclarée, vous allez avoir des avertissements.
Le compilateur va supposer que la fonction renvoie un int.
Il est toujours plus sûr d'inclure cette déclaration de prototype en
haut pour toutes les fonctions
que vous appelez, soit
explicitement, soit implicitement en incluant le fichier d'en-tête correct dans votre programme.
Mais lorsque vous n'incluez pas cela, ces déclarations de prototype peuvent
contenir des erreurs.
Ne pas inclure le fichier d'en-tête qui comprend la définition d'une fonction
de bibliothèque de programmation c utilisée dans le programme.
Donc, dans ce cas, vous souhaitez réutiliser du code. Peut-être que vous avez la fonction
printf que vous souhaitez afficher une sortie, mais vous n'incluez pas le fichier d'en-tête standard lib.
C'est une erreur. Et cela vous sera généralement dit par le compilateur.
Il y aura un problème de
liaison avec cette fonction.
Donc, dans ce cas, nous avons une double réponse égale la valeur de la racine carrée 1.
Si ce programme n'inclut pas les maths. d'en-tête, cela générera
une erreur indiquant que la racine carrée n'est pas définie.
Il va essayer de lier les fichiers objets. Il n'y aura pas de calcul. o.
Et il dira, hé, vous appelez la racine carrée, mais il n'y a pas d'implémentation pour cela.
Assurez-vous donc d'inclure les en-têtes corrects pour toutes
vos invocations de fonctions, en particulier à partir de la bibliothèque standard.
Confondre une constante de caractère dans une chaîne de caractères.
Donc, ici, si nous avons du texte égal à des guillemets simples
à l'intérieur, c'est un seul caractère attribué au texte.
Si nous avons une variable nommée text et que nous l'attribuons entre
guillemets, c'est un pointeur vers la chaîne de caractères.
Ce n'est pas valable pour un
seul caractère.
Et cela en fait, nous avons parlé des constantes
de chaîne et de leur attribution à des tableaux de caractères.
Et comment vous ne pouvez pas faire cela avec les égaux et vous
devez les faire avec la copie étoile.
Dans ce cas, lorsque nous disons que le texte est égal à a, il attribue un pointeur et ce
n'est en fait pas valide non plus et voyez
ce que vous auriez à faire est que vous deviez faire le texte en
étoile égal à a ou la copie en étoile si vous ne le faites pas. Je ne
veux pas l'attribuer directement comme ça.
Mais vous comprenez l'essentiel.
Utiliser un intérieur de guillemets simples par rapport à un caractère entre guillemets
doubles complètement différent, caractère par rapport à une chaîne.
Dans le premier cas, le texte est normalement déclaré comme une variable char.
Et dans le second cas, il doit être déclaré comme étant un pointeur de type vers un char.
Et si vous souhaitez attribuer une valeur à ce pointeur
autre que le pointeur lui-même, vous devez le dé-référencer.
C'est en fait incorrect car s'il s'agit d'un
pointeur au lieu d'attribuer une adresse, vous lui attribuez une chaîne, ce qui
n'a aucun sens.
Utilisation des mauvaises limites pour un tableau, exception tableau hors limites.
Ici, nous déclarons un tableau d'entiers de taille 100, puis un couple
de variables I et somme avec seulement quelques-unes en cours d'initialisation.
Et nous parcourons notre boucle, nous disons que pour I égal à 1 I est inférieur à égal à 100.
C'est incorrect car la taille d'une centaine signifie qu'il y a cent
éléments dans le tableau. Mais les tableaux sont basés sur zéro.
Le premier élément est donc zéro. L'index max que vous
pouvez attribuer ou accéder dans un tableau est 99.
Cela va à moins qu'égal.
Vous allez donc avoir une erreur hors limites ici.
Ce n'est pas un
indice valide car cette boucle va aller jusqu'à 100.
C'est aussi probablement incorrect parce que vous commencez à 1.
Si vous vouliez vraiment le premier élément de ce tableau, vous commenceriez à 0.
Oublier de réserver un emplacement supplémentaire dans un tableau pour
le caractère nul de fin d'une chaîne
est également un problème courant.
Lors de la déclaration de vos tableaux de caractères, ils doivent être suffisamment grands pour contenir le caractère de fin seul.
C'est pourquoi je vous suggère de ne pas
mettre de taille dans un tableau lorsque vous le créez si vous l'initialisez.
Vous ne mettriez la taille là-dedans que si vous ne l'initialisez pas.
Si vous créez une initialisation sur la même ligne, laissez c faire
le travail pour vous, il mettra automatiquement la bonne taille et il inclura ce terminateur nul.
Ainsi, par exemple, si vous avez une chaîne de caractères appelée bonjour,
c'est plus de cinq emplacements de mémoire, c'est six à cause de ce terminateur nul à la fin.
N'oubliez pas la taille de vos tableaux.
C'est un problème courant avec les pointeurs dont nous n'avons pas beaucoup discuté, mais
je voulais simplement le mentionner car c'est très courant.
Dans les pointeurs, lorsque vous souhaitez accéder ou même instruire, lorsque
vous souhaitez accéder à quelque
chose par un pointeur, vous devez utiliser le tiret supérieur au symbole.
Cela est utilisé lorsque vous accédez à un élément de pointeur.
Donc, si vous avez un pointeur qui pointe vers une structure, c'est ainsi que vous y accédez.
Si vous avez une structure, ce
n'est pas un pointeur, alors vous y accédez à l'aide d'un opérateur point.
Souvent, cet opérateur point et ce tiret sont alors plus grands que
ne sont utilisés correctement.
Dot pour les non-pointeurs, les pointeurs tirent plus grand que, cela deviendra
clair dans plus de nos exemples.
Omettre l'esperluette avant les variables sans pointeur dans un appel scanf.
Rappelez-vous donc que notre appel scanf attend un pointeur comme deuxième argument, et
cela signifie une adresse.
Lorsque nous déclarons un type de données une variable de type int, ce n'est
pas un pointeur.
Donc, pour permettre à scanf de stocker ces données dans notre variable int, nous devons lui
passer l'esperluette pour dire que c'est une adresse.
C'est donc incorrect, ne
pas avoir l'esperluette avant le nombre et scanner f car le
deuxième argument n'est pas valide. La seule fois où vous n'avez pas l'esperluette, c'est si vous utilisez un
pointeur, comme un tableau de caractères.
Tous les arguments apparaissant après la chaîne de format et scanf doivent être des pointeurs.
Utilisation d'une variable de pointeur avant son initialisation.
Voici donc un exemple de création d'un pointeur, puis de tentative de l'attribuer.
Et c'est l'affectation correcte où vous attribuez une valeur que vous dé-référencez.
Mais ce que nous n'avons pas fait ici, c'est que nous avons initialisé le pointeur pour avoir en
fait de la mémoire allouée et vous ne
pouvez pas le faire en c.
Vous ne pouvez appliquer l'opérateur d'indirection, qui
est l'astérisque avant, à un point
ou une variable après avoir défini la variable pointant quelque part.
Donc, il doit pointer quelque part, pour le moment, il est nul, il ne pointe nulle part parce que
vous n'avez alloué aucune mémoire.
Ainsi, le pointeur char n'est jamais défini pour pointer vers quoi que ce soit, l'affectation n'est donc pas significative.
Cela provoquerait en fait une erreur de segmentation.
Une autre erreur courante consiste à omettre l'instruction break à la fin d'un cas dans une instruction switch.
Si la rupture n'est pas incluse à la fin d'un cas, l'exécution se poursuit au cas suivant.
C'est donc ce que j'ai mentionné lorsque vous avez un cas, il est évalué.
Et si vous n'avez pas cette pause là-dedans, cela passe
directement au cas suivant et exécutera le code dans ce cas suivant.
Vous voulez donc toujours avoir des pauses dans vos déclarations de cas.
Il y a des moments où vous voulez avoir un cas de suivi dans un
autre cas et ils font exactement la même chose, dans
ce cas, vous n'auriez rien à l'intérieur de la déclaration de cas.
Insertion d'un point-virgule à la fin d'une définition de préprocesseur.
Les définitions de préprocesseur se souviennent de commencer par
le nombre, le symbole dièse. Le préprocesseur est exécuté avant le compilateur
généralement pour l'optimisation.
La syntaxe correcte pour les définitions de préprocesseur ne doit pas inclure de point-virgule.
Cependant, en c vous, prenez l'habitude de toujours mettre un point-virgule après tout.
Mais vous devez vous rappeler que si vous définissez des données constantes dont
vous n'avez pas besoin du point-virgule, c'est incorrect.
Cela entraînera une erreur de syntaxe si
une expression comme celle-ci est utilisée.
comme ça. Donc, si vous essayez réellement d'utiliser
cela pour trouver, ce n'est pas grave d'avoir ce point-virgule à la fin.
Mais lorsque le préprocesseur s'exécute, il insère exactement ce qui est défini.
Donc ça va servir à la fin des données 999 deux-points.
C'est ce que le compilateur va voir et cela va en fait provoquer une erreur, ce
serait une erreur de syntaxe.
Omettre une parenthèse fermante ou des guillemets fermants sur n'importe
quelle instruction, très courant. Donc, cela est également directement lié
aux crochets, ayant une accolade de départ et ne terminant pas l'accolade, même
chose avec les parenthèses. Dans ce cas, nous
avons deux ou trois parenthèses de départ à gauche, mais nous n'avons
que deux parenthèses de fin. Il nous manque une fin entre parenthèses droites.
Ce serait une erreur de syntaxe que le compilateur trouverait.
Ainsi, lorsque vous utilisez l'intégration entre parenthèses pour séparer chaque partie d'une équation, cela donne
une ligne de code plus lisible.
Vous souhaitez utiliser des parenthèses.
Cependant, vous voulez vous assurer qu'ils correspondent tous
que vous commencez une parenthèse, vous devez avoir une parenthèse fermante de fin, la même chose avec les accolades.
Vous commencez une accolade, elle doit avoir une accolade de fin.
Donc, soit vous en avez trop, soit vous en
avez trop peu, mais le compilateur va se plaindre, et c'est très, très courant.
Donc, la deuxième ligne ici manque également un guillemet de fermeture, cette instruction d'impression.
Nous n'avons pas de citation de fin.
Le compilateur s'en plaindra.
Les deux généreront une erreur de compilation.
Parfois, le compilateur est très trompeur car il ne sait
pas vraiment où l'erreur se produit. Il pense que l'erreur a pu se produire sur une ligne suivante.
Donc, la ligne qui vous indique l'erreur peut être trompeuse.
Donc, selon que le compilateur
utilise une parenthèse ou un guillemet sur une
ligne suivante, il complétera réellement cette expression.
Donc, cela déplacera l'erreur vers une autre ligne.
Et c'est ce qu'il va se plaindre et dire que c'est là que se trouve l'erreur. Mais l'erreur réelle
est plus élevée au-dessus de l'endroit où vous vouliez la placer.
Ce sont des erreurs courantes que je vois faire beaucoup de
programmeurs c.
Ils sont faciles à réparer. Et si vous les comprenez et
les étudiez, vous saurez
que vous ne devez pas les fabriquer. C'est correct de les faire
en tant que débutant, mais à mesure que vous codez de plus
en plus et que vous vous pratiquez, vous vous rendrez compte, hé,
j'ai oublié une parenthèse, j'ai oublié une parenthèse, je n'ai pas utilisé correctement les égaux et les
égaux. , J'utilise des pointeurs de manière incorrecte, je n'ai alloué aucune mémoire.
Toutes ces choses viendront plus d'une seconde nature. Merci.