10 façons d'éviter les bugs en C ++

Il est regrettable que vous passerez plus de temps à chercher et enlever les bugs que vous passerez réellement écrire votre programmes C ++, en premier lieu. Les suggestions ici peuvent vous aider à réduire le nombre d'erreurs que vous introduisez dans vos programmes pour faire la programmation d'une expérience plus agréable.

Activer tous les avertissements et messages d'erreur

La syntaxe de C ++ permet pour beaucoup de contrôle d'erreur. Lorsque le compilateur rencontre une construction qui ne peut tout simplement pas déchiffrer, il n'a pas d'autre choix que de délivrer un message. Il essaie de synchroniser de retour avec le code source (parfois moins de succès), mais il ne sera pas générer un exécutable. Cela force le programmeur de fixer tous les messages d'erreur.

Toutefois, lorsque C ++ vient à travers une structure qu'il peut comprendre, mais la structure sent le poisson de toute façon, C ++ génère un message d'avertissement. Parce que C ++ est à peu près sûr qu'il comprend ce que vous voulez, il va de l'avant et crée un fichier exécutable de sorte que vous pouvez ignorer les avertissements si vous le souhaitez. En fait, si vous ne voulez vraiment pas être dérangé, vous pouvez désactiver les avertissements.

Désactivation ou autrement avertissements ignorant est extraordinairement mauvaise idée. Il est un peu comme de débrancher le “ vérifier le moteur ” lumière sur le tableau de bord de votre voiture parce que cela vous dérange. Ignorer le problème ne fait pas disparaître.

Adopter un style clair et cohérent de codage

Rédaction de votre code C ++ dans un style clair et cohérent non seulement améliore la lisibilité de votre programme, mais il entraîne également moins d'erreurs de codage. Cet état quelque peu surprenant d'affaires résulte du fait que nos cerveaux ont seulement une quantité limitée de puissance de calcul.

Quand vous lisez le code qui est propre et soigné et qui suit un style que vous êtes familier avec, vous passez très peu d'énergie du cerveau analyse la syntaxe des déclarations C ++. Cela laisse plus de puissance CPU cerveau pour décoder ce que le programme tente de faire et non comment il le fait.

Un bon style de codage vous permet de faire ce qui suit avec facilité:

• La différence entre les noms de classes, les noms d'objets, et les noms de fonctions

• Comprendre ce qu'est la classe, de la fonction, ou l'objet est utilisé pour, sur la base de son nom

• Différencier les symboles de préprocesseur de symboles C ++ (qui est, #define objets devraient se démarquer)

• 
  
  
  
  

  Identifier les blocs de code C de au même niveau (ce qui est le résultat d'indentation cohérente)

En outre, vous devez établir un format standard pour vos têtes de module qui fournit des informations sur les fonctions ou des classes dans chaque module, l'auteur, la date, la version, et quelque chose sur l'histoire de la modification.

Tous les programmeurs impliqués dans un même projet doivent utiliser le même style de codage. Un programme écrit en un patchwork de styles différents de codage est confuse et ne semble pas professionnel.

Commentaire du code pendant que vous écrivez

Vous pouvez éviter les erreurs si vous commentez votre code pendant que vous écrivez, plutôt que d'attendre jusqu'à ce que tout fonctionne et puis revenir en arrière et ajouter des commentaires.

Formuler commentaires vous oblige à faire le point sur ce que vous essayez de faire. Courts commentaires sont éclairantes, à la fois lorsque vous les lire plus tard et que vous les écrire. Écrire des commentaires que si vous parlez à un autre, programmeur compétent.

Simple étape chaque chemin dans le débogueur au moins une fois

En tant que programmeur, vous devez comprendre ce que fait votre programme. Il ne suffit pas que le programme fournit en sortie la valeur attendue. Vous avez besoin de comprendre tout ce que fait votre programme. Rien ne vous donne une meilleure idée de ce qui se passe sous le capot que mode pas à pas le programme, l'exécution étape par étape avec un bon débogueur (comme celui qui vient avec Code :: Blocks).

Au-delà de ce que, comme vous déboguer un programme, vous avez besoin de matières premières à comprendre certains comportements bizarres qui pourraient surgir que le programme fonctionne. Rien ne vous donne que le matériel mieux que simple pas à pas dans chaque fonction son entrée en service.

Enfin, lorsqu'une fonction est fini et prêt à être ajoutés au programme, chaque chemin logique doit être parcourue au moins une fois. Bugs sont beaucoup plus faciles à trouver quand vous examinez la fonction en elle-même plutôt que après qu'il a été jeté dans le pot avec le reste des fonctions - d'ici là, votre attention a continué à de nouveaux défis de programmation.

Limiter la visibilité

Limiter la visibilité des internes de classe au monde extérieur est une pierre angulaire de la programmation orientée objet. La classe doit être responsable de son état interne - si quelque chose se fait défoncer dans la classe, alors il est de la faute de la classe programmeur. Le programmeur d'application devrait se soucier de résoudre le problème à la main.

Plus précisément, la visibilité limitée signifie que les membres de données ne devraient pas être accessibles en dehors de la classe - qui est, ils doivent être marqués comme protégés. En outre, les fonctions de membres que le logiciel d'application n'a pas besoin de connaître doivent également être marqué protégés. Ne pas exposer plus des internes de classe que nécessaire pour faire le travail.

Gardez une trace de mémoire de tas

Perdre la trace de mémoire de tas est la source la plus commune des erreurs fatales dans les programmes qui ont été libérés dans le domaine - et, dans le même temps, le problème le plus difficile à traquer et enlever. (Parce que cette classe d'erreur est si difficile à trouver et à enlever, il est fréquent dans les programmes que vous achetez.) Vous pourriez avoir à exécuter un programme pendant des heures avant que les problèmes commencent à se poser (en fonction de l'ampleur de la fuite de mémoire est).

En règle générale, les programmeurs doivent toujours allouer et de libérer de la mémoire de tas dans le même “. Niveau n ° 148; Si une fonction de membre MyClass :: create () alloue un bloc de mémoire de tas et il retourne à l'appelant, puis il devrait y avoir un membre MyClass :: release () qu'il retourne sur le tas. Plus précisément, MyClass :: create () ne devrait pas exiger la fonction de parent pour libérer la mémoire.

Si possible, Ma classe devrait garder une trace de ces pointeurs de mémoire sur son propre et les supprimer dans le destructeur.

Zéro pointeurs sur après la suppression de ce qu'ils pointent vers

Assurez-vous que vous concentrer sur des pointeurs après qu'ils ne sont plus valide- vous le faites en leur attribuant la valeur nullptr. Les raisons de cette action deviennent clairs avec l'expérience: Vous pouvez continuer à utiliser un bloc de mémoire qui a été remis au tas et sans même le savoir. Un programme pourrait fonctionner bien 99 pour cent du temps, ce qui rend très difficile de trouver le 1 pour cent des cas où le bloc se réaffectés et le programme ne fonctionne pas.

Si vous NULL sur pointeurs qui ne sont plus valables et que vous tentez de les utiliser pour stocker une valeur (vous ne pouvez pas stocker quoi que ce soit à ou près de l'emplacement null), votre programme va planter immédiatement. Crashing sonne mal, mais il est pas si il expose un problème. Le problème est dès qu'elle est simplement une question de savoir si vous trouvez qu'il est ou non avant de le mettre en production.

Utilisez des exceptions pour gérer les erreurs

Le mécanisme d'exception en C ++ est conçu pour gérer les erreurs facilement et efficacement. En général, vous devriez jeter un indicateur d'erreur plutôt que de retourner un drapeau d'erreur. Le code résultant est plus facile à écrire, lire, et à entretenir. En outre, d'autres programmeurs sont venus à attendre, et vous ne voudriez pas les décevoir, souhaitez-vous?

Limitez votre consommation d'exceptions aux véritables erreurs. Il est pas nécessaire de lancer une exception à partir d'une fonction qui retourne une “ ne fonctionnait ” Indicateur si cela fait partie de la vie quotidienne pour cette fonction.

Déclarer destructeurs virtuels

Ne pas oublier de créer un destructeur de votre classe si le constructeur alloue des ressources telles que la mémoire de tas qui doivent être retournés lorsque l'objet atteint sa disparition définitive. Après avoir créé un destructeur, ne pas oublier de déclarer virtuel.

“ Mais, ” tu dis, “ ma classe ne hérite pas de quoi que ce soit, et il ne sous-classe par une autre classe ”. Oui, mais il pourrait devenir une classe de base à l'avenir. Sauf si vous avez une bonne raison pour ne pas déclarer le destructeur virtuel, puis le faire lorsque vous créez la classe.

Fournir un constructeur de copie et opérateur d'affectation surchargé

Si votre classe a besoin d'un destructeur, il faut presque sûrement un constructeur de copie et un opérateur d'affectation surchargé. Si votre constructeur alloue des ressources telles que la mémoire de tas, le constructeur de copie par défaut et opérateur d'affectation ne fera rien, mais créer le chaos en générant plusieurs pointeurs vers les mêmes ressources.

Lorsque le destructeur de l'un de ces objets est appelé, il va restaurer les actifs. Lorsque le destructeur de l'autre copie est long, il sera vis les choses.