Quelle est une bonne approche générale pour décider des valeurs de retour en C?

Alors, comment puis-je ajouter de la clarté à mon approche lorsque vous décidez des types de retour ici?

Le fait que vous pensiez à cela va un long chemin. Si vous proposez une ou deux règles - ou encore plus si elles ont du sens (vous pourriez avoir besoin de plus d'une règle - comme vous le mentionnez, vous voudrez peut-être gérer des pointeurs retournés différemment plutôt que d'autres choses), je pense que vous serez mieux éteint que beaucoup de magasins.

J'aime personnellement avoir 0 retourné à une défaillance du signal et non à zéro pour indiquer le succès, mais je n'ai pas de forte besoin de tenir à cela. Je peux comprendre la philosophie qui voudra peut-être inverser ce sens afin de pouvoir renvoyer différentes raisons de l'échec.

La chose la plus importante est de disposer de directives qui sont suivies. Même plus agréable est d'avoir des lignes directrices qui ont une justification documentée (je pense qu'avec les rationnelles, les gens sont plus susceptibles de suivre les directives). Comme je l'ai dit, juste le fait que vous pensiez à ces choses vous met en avant de nombreux autres.

Pas une réponse réelle à votre question, mais quelques commentaires aléatoires, vous pourriez trouver intéressant:

• Il est normalement évident quand utiliser un cas (1), mais il devient laid lorsque des types non signés sont impliqués - retour (taille_t) -1 code> fonctionne toujours, mais ce n'est pas joli li>

• Si vous utilisez C99, il n'y a rien de mal à utiliser _bool code>; imo, c'est beaucoup plus propre que d'utiliser un int code> p> li>

• i utilise renvoyer null code> au lieu de renvoyer 0 code> dans les contextes de pointeur (préférence péronale), mais je vérifie rarement cela comme je le trouve plus naturel pour simplement traiter le pointeur comme un booléen; Un cas commun ressemblerait à ceci: p>

  struct foo *foo = create_foo();
  if(!foo) /* handle error */;
  

• J'essaie d'éviter l'affaire (2); Utilisation de EXIT_SUCCESS CODE> et EXIT_FAILURE CODE> Peut être réalisable, mais IMO Cette approche n'a aucun sens si il y a plus de deux résultats possibles et que vous devrez utiliser un Enum Quoi qu'il en soit p> li>

• Pour des programmes plus compliqués, il pourrait être logique de mettre en œuvre votre propre schéma de traitement des erreurs; Il existe des implémentations assez avancées à l'aide de SETJMP () code> / longjmp () code> autour, mais je préfère quelque chose errno code> à différentes variables pour différents types d'erreurs p> li> ul> p>

Pourquoi n'utilisez-vous pas la méthode utilisée par la bibliothèque standard C? Oh, attends ...

pour ne peut pas échouer déterministe. Oui / Non Les réponses à l'aide d'un type de retour plus spécifique (BOOL) peuvent aider à maintenir la cohérence. Aller plus loin pour des interfaces de niveau supérieur, on peut vouloir penser à renvoyer ou à mettre à jour une structure spécifique de messagerie / de détail de résultats spécifique.

Ma préférence pour 0 Pour toujours être un succès est basée sur les idées suivantes:

1. zéro permet de classer de base pour organiser des échecs par des valeurs négatives et positives telles que la défaillance totale du succès conditionné. Je ne recommande pas cela généralement comme il a tendance à être un peu trop peu profond pour être utile et pourrait entraîner des hypothèses comportementales dangereuses.

2. Lorsque le succès est nul, on peut créer un tas d'appels orthogonaux et vérifier le succès du groupe dans une seule condition plus tard en comparant le code de retour du groupe.

   rc = 0; rc + = func1 (); rc + = func2 (); rc + = func3 (); Si (rc == 0) Succès!

3. Plus important encore de zéro de mon expérience semble être une indication cohérente du succès lorsque vous travaillez avec des bibliothèques standard et des systèmes tiers.

C'est une question de préférence, mais ce que j'ai remarqué est l'incohérence. Considérez ceci à l'aide d'un compilateur PRE C99

#define SUCCESS  1
#define ERROR    0

Alors, comment puis-je ajouter de la clarté à mon approche lorsque vous décidez des types de retour ici?

Choisissez un modèle par type de retour et collez-le avec celui-ci, ou vous vous conduirez fou. Modèle votre motif sur les conventions qui ont longtemps été établies pour la plate-forme:

• Si vous faites beaucoup d'appels système, une fonction de retour entier doit renvoyer -1 sur une défaillance.

• Si vous ne faites pas d'appels de système, vous êtes libre de suivre la convention des structures de contrôle C que non nulle signifie réussir et zéro signifie échec. (Je ne sais pas pourquoi vous n'aimez pas bool .)

• Si une fonction renvoie un pointeur, une défaillance doit être indiquée en retournant null .

• Si une fonction renvoie un numéro de point flottant, une défaillance doit être indiquée en renvoyant une NAN.

• Si une fonction renvoie une gamme complète d'entiers signés et non signés, vous ne devez probablement pas coder le succès ou l'échec de la valeur de retour.

  Test des valeurs de retour est un fléau aux programmeurs C. Si l'échec est rare et que vous pouvez écrire un gestionnaire central, envisagez d'utiliser un Package macro d'exception qui peut indiquer des échecs à l'aide de longjmp .