Comment puis-je améliorer ma vérification et ma gestion des erreurs?

Dernièrement, j'ai eu du mal à comprendre quelle est la bonne quantité de vérification et quelles sont les bonnes méthodes.

J'ai quelques questions à ce sujet:

Quelle est la bonne façon de vérifier les erreurs (mauvaise entrée, mauvais états, etc.)? Est-il préférable de vérifier explicitement les erreurs ou d'utiliser des fonctions comme les assertions qui peuvent être optimisées à partir de votre code final? J'ai l'impression de vérifier explicitement l'encombrement d'un programme avec beaucoup de code supplémentaire qui ne devrait pas être exécuté dans la plupart des situations - et sans parler de la plupart des erreurs se terminent par un échec d'abandon / sortie. Pourquoi encombrer une fonction avec des vérifications explicites juste pour abandonner? J'ai cherché des assertions contre une vérification explicite des erreurs et j'ai trouvé peu de choses pour vraiment expliquer quand faire l'une ou l'autre.

La plupart disent «utiliser des assertions pour vérifier les erreurs logiques et utiliser des vérifications explicites pour rechercher d'autres échecs». Cela ne semble cependant pas nous mener très loin. Dirions-nous que cela est possible:

Malloc returning null, check explictly
API user inserting odd input for functions, use asserts

Est-ce que cela me ferait mieux de vérifier les erreurs? Que puis-je faire d'autre? Je veux vraiment améliorer et écrire mieux, du code «professionnel».

Le moyen le plus simple pour moi de faire la différence est de déterminer si la condition d'erreur est introduite au moment de la compilation ou de l'exécution. Si le problème est qu'un programmeur utilise la fonction de manière incorrecte, faites-en un assert pour attirer l'attention sur le problème, mais une fois que le correctif est compilé dans le code appelant, vous n'avez plus à vous soucier de le vérifier. Les problèmes comme le manque de mémoire ou les entrées incorrectes de l'utilisateur final ne peuvent pas être résolus au moment de la compilation, vous devez donc laisser les vérifications.

Vérifiez à tout moment (cela aurait pu changer après votre dernier contrôle) qui n'est pas à 100% sous votre commande. Et aussi: Pendant le développement même ne vous fiez pas! ;-)

Okokok ... "n'importe quoi" est censé être lu comme la vérification de telles choses qui pourraient provoquer un abandon anormal ou tout ce qui pourrait faire faire à votre application / système des choses qu'elle ne devrait pas faire.

Pour être sérieux, la dernière partie de la dernière phrase est essentielle car elle pointe sur le problème principal:

Si vous voulez construire un système stable, la préoccupation principale ne concerne pas ce que le système doit faire, mais pour lui permettre de faire des choses obligatoires, il faut faire attention à ce qu'il ne doit pas faire, même s'il "encombre votre code".

Le nœud du traitement des erreurs n'est pas de savoir si et comment vous attrapez le problème. C'est plus ce que vous faites après en avoir entendu parler .

Tout d'abord - je dirais qu'il n'y a aucune raison pour que toute erreur renvoyée par une méthode subordonnée ne soit pas traitée. Et les erreurs et exceptions sont juste plus que les valeurs de retour ou toutes les tentatives / captures.

1. Lancer et attraper ne suffit pas.
   Regarde ça : où l'auteur explique que le simple fait d'attraper mais de ne rien faire supprime potentiellement l'exception et à moins que suffisamment d'efforts soient faits pour réparer les dommages - c'est pire que de laisser le code disparaître comme ça. De même, le simple fait d'écrire une instruction «log» quand il y a un fichier ouvert ou une erreur de lecture pourrait aider à trouver la raison - mais à la fin du programme, cela pourrait avoir endommagé les données! Il ne suffit pas de dire que j'ai beaucoup d' essais / prises - il est plus important de savoir ce qu'ils font vraiment!

2. N'abusez pas de la tentative et de la capture.
   Parfois, la plupart du temps des programmeurs paresseux ou naïfs pensent qu'après avoir écrit suffisamment de try / catch, leur travail est terminé et facile. Très souvent, il est préférable d'appliquer des mesures correctives et de reprendre plutôt que de simplement vider le tout. Si cela ne peut pas être fait, il faut décider à quel niveau vous devez revenir. Selon le contexte et la gravité, essayez d'imbriquer les captures nécessite une conception soignée. Par exemple - Voir ceci et cela

3. Définissez qui est responsable:
   L'une des premières choses que vous devez faire est de définir si l'entrée donnée à la routine elle-même est juste un scénario inacceptable (ou non géré jusqu'à présent) ou est l'exception due à l'environnement (comme un problème système, un problème de mémoire), ou cette situation est-elle entièrement interne, issue du résultat de l'algorithme? Dans tous les cas, le niveau auquel vous souhaitez revenir ou l'action que vous souhaitez entreprendre diffère considérablement. Dans cette optique, je voudrais dire - que lorsque vous exécutez le code en production - faire abort () pour quitter le programme est bon - mais pas pour chaque petite chose. Si vous repérez une corruption de mémoire ou une mémoire insuffisante, il est certain que même après avoir fait de votre mieux - les choses vont mourir. Mais si vous recevez un pointeur NULL à l'entrée - je ne le ferais pas

4. Définissez quel est le meilleur résultat possible:
   tout ce qui doit être fait sous exception est très critique. Par exemple, si dans l'un de nos cas - un lecteur multimédia constate qu'il n'a pas de données complètes à lire à l'utilisateur - que doit-il faire?

   • soit sauter une mauvaise partie et voir si elle peut aller de l'avant avec de bonnes choses.
   • si cela se produit trop, pensez à passer à la chanson suivante.
   • s'il constate qu'il ne peut lire aucun fichier, arrêtez et montrez quelque chose.
   • pendant ce temps
   • en vertu de laquelle un État devrait POP-UP joueur à l'utilisateur et
   • quand doit-il continuer seul?
   • Devrait-il "arrêter" des choses pour demander aux utilisateurs de revenir
   • ou devrait-il mettre une petite note d'erreur discrète dans un coin?

   Tout cela est subjectif - et il y a peut-être plus de façons de gérer les problèmes que nous ne le pensons trivialement. Tout ce qui précède nécessite de construire et de comprendre la profondeur de l'exception et de faire également différents scénarios devraient pouvoir évoluer vers.

5. Parfois, nous devons vérifier les exceptions avant qu'elles ne surviennent. L'exemple le plus courant est la division par zéro erreur. Idéalement, il faut tester qu'avant qu'une telle exception ne soit levée - et si c'est le cas - essayer de mettre la valeur non nulle la plus appropriée et continuer plutôt que de se suicider!

6. Nettoyer. C'est du moins ce que vous devez faire! Si une fonction arrive à ouvrir 3 fichiers et que le quatrième ne s'ouvre pas - inutile de dire que les 3 premiers auraient dû être fermés. Déléguer ce travail à une couche au-dessus est une mauvaise idée. si vous décidez de ne pas partir sans nettoyer la mémoire. Et le plus important - même si vous avez survécu à l'exception, informez plus haut que les choses n'ont pas suivi le cours normal.

La façon dont nous voyons les fonctionnalités (normales) du logiciel en termes de diverses hiérarchies ou couches ou abstractions, de la même manière que nous devons catégoriser les exceptions en fonction de leur gravité ainsi que de la portée sous laquelle elles se produisent et qu'elles affectent d'autres parties du système - qui définit comment gérer ces différentes exceptions de la meilleure façon possible.

Meilleure référence: Code Craft chapitre 6 - disponible en téléchargement

La vérification des erreurs uniquement pendant les versions de débogage est une MAUVAISE IDÉE (tm), compilant sous les superpositions de versions des variables réutilisables sur la pile, supprime les pages de garde, effectue des tours difficiles avec des calculs, remplace les arthritiques lourdes par des décalages précalculés, etc.

Utilisez également la vérification des erreurs dans la version, vous pouvez recourir à quelque chose d'aussi simple que:

if(somethinghitthefan)
     abort();

Cela a également un très bon effet secondaire que vous n'ignorerez certainement pas le bogue une fois que l'application commencera à planter sur le PC des testeurs betta.

Les visualiseurs d'événements et les journaux sont complètement inutiles par rapport à abort(), qui les vérifie quand même?

Les différentes choses que vous pouvez faire est
1.Read et beaucoup assimilent de code en ligne et voir comment il est fait
2.Utiliser certains outils de débogage pour vous aider à localiser les régions d'erreurs
3.Be au courant des erreurs insignifiantes en raison de mauvaises affectations et erreurs de syntaxe.
4. Certaines erreurs pires surviennent en raison d'erreurs logiques dans le programme qui sont plus difficiles à trouver .Pour cela, vous pouvez le saisir et trouver ou pour les plus compliquées, essayez de parler aux gens ou utilisez des ressources comme Stackoverflow , Wikipedia , google pour obtenir de l'aide. gens.