Est-il sécuritaire de renommer argc et argv dans la fonction principale?

De nombreux programmes utilisent des noms standard pour un certain nombre d’arguments et de tableaux de chaînes. Le prototype de la fonction principale ressemble à: int main(int argc, char *argv[]); . Mais pourrais-je casser quelque chose si je choisis des noms personnalisés pour ces variables?

Par exemple int main(int n_of_args, char *args[]);

Dans le contexte du compilateur, tout va bien. Ces variables sont locales pour la fonction principale, elles peuvent donc avoir des noms. Et le code simple se construit et fonctionne parfaitement. Mais ces noms peuvent être utilisés par le préprocesseur. Est-il donc sûr de renommer ces arguments?

PS Personnellement, je trouve ces noms incorrects, car ils sont très similaires et ne diffèrent que par une seule lettre. Mais chacun les utilise pour une raison quelconque.

Oui, c’est sûr, tant que vous utilisez des noms de variables valides. Ce sont des variables locales, de sorte que leur scope ne dépasse pas la fonction main .

De la section 5.1.2.2.1 de la norme C :

La fonction appelée au démarrage du programme est nommée main . L’implémentation ne déclare aucun prototype pour cette fonction. Il doit être défini avec un type de retour de int et sans paramètre:

 int main(void) { /* ... */ } 

ou avec deux parameters (appelés ici argc et argv , bien que tous les noms puissent être utilisés, car ils sont locaux à la fonction dans laquelle ils sont déclarés ):

 int main(int argc, char *argv[]) { /* ... */ } 

ou équivalent; ou d’une autre manière définie par la mise en œuvre

Cela étant dit, utiliser autre chose que argc et argv pourrait argv erreur les autres personnes qui lisent votre code et qui sont habitués aux noms conventionnels de ces parameters. Donc, il vaut mieux pécher par excès de clarté.

Les noms argc et argv étaient en réalité mandatés par le standard C ++ antérieur à C ++ 11. Il a déclaré:

Toutes les implémentations doivent autoriser les deux définitions suivantes de main:

 int main () 

et

 int main ( int argc , char * argv []) 

et a continué à discuter des exigences sur argc et argv .

Donc, techniquement, tout programme utilisant des noms différents n’était pas conforme à la norme et le compilateur était autorisé à le rejeter. Aucun compilateur ne l’a fait, bien sûr. Voir cette discussion sur comp.std.c ++ ou la section 3.6.1 de ce projet de norme C ++ 03 .

C’était presque certainement un simple oubli, et a été changé en C ++ 11, qui dit plutôt

Toutes les implémentations doivent permettre les deux

  • une fonction de () retournant int et
  • une fonction de ( int , pointeur sur le pointeur vers char ) renvoyant int

comme type de main (8.3.5). Dans ce dernier cas, pour les besoins de l’exposition, le premier paramètre de fonction s’appelle argc et le second paramètre de fonction s’appelle argv ,…

Bien sûr, vous pouvez renommer ces parameters en toute sécurité comme vous le souhaitez

  int main(int wrzlbrnft, char* _42[]) { } 

Les noms sont écrits dans le sable. Ils n’ont aucune influence sur le code finalement compilé.


La seule chose qui compte, c’est que les types de déclaration et de définition de paramètre correspondent réellement.

La signature de la fonction main() est insortingnsèquement déclarée comme

  int main(int, char*[]); 

Si vous devez les utiliser dans une implémentation, vous devrez les nommer. Les noms utilisés ne sont pas pertinents, comme mentionné précédemment.

Oui. C’est sûr, ça a l’air bizarre, mais ça ne cassera rien.

Oui, il est prudent d’utiliser des noms différents.

Personnellement, je ne le recommanderais pas, car l’ argc et l’ argv traditionnels sont très connus et familiers à tous les autres programmeurs C qui pourraient travailler avec votre code. À long terme, l’utilisation de vos propres noms spéciaux et différents vous causera beaucoup plus de confusion et / ou de frustration chez vos lecteurs qu’elle ne vous sauvera jamais parce que vous aimez mieux vos noms.

“A Rome, fais comme les Romains.”

Oui, vous pouvez les renommer comme vous le souhaitez. Ce sont simplement des noms de parameters de fonction, rien de plus.

Je pense que tout le monde a bien traité les règles techniques du c ++: la réponse est oui. Mettons de côté la tradition et le fait que cette fonction particulière est spéciale et iconique, qui contient des points valables pour ne pas changer sur cette base.

Souvent, j’estime que la philosophie des choix est rarement discutée et que, par conséquent, je voulais offrir une perspective à ce sujet, car j’estime que cela est important pour la raison pour laquelle cela a été demandé.

Cette question pour moi implique un choix en exprimant l’anglais dans le code en général. Vous semblez être dérangé par les descriptions courtes, en particulier si la main courte pose un texte similaire. Dans votre exemple, cependant, changer argn en n_of_args ne fait que transformer un type d’aiguille courte en une autre forme de sténographie sans réelle valeur ajoutée: clarification ou autres propriétés visibles.

Le mot “nombre” a été remplacé par une lettre “n”.

Si vous modifiez un nom de main courte via la philosophie de l’anti-main courte, cela peut sembler plus approprié:

main (int argumentCount, char ** argumentVector)

Je pense toujours à deux choses: Nommer les choses par ce qu’elles sont et / ou par leur utilisation implicite. L’appeler un argumentVector m’est redondant puisque la propriété d’être un vecteur est impliquée par la double indirection **. Ainsi, une meilleure façon de rédiger du code est: ** arguments.

Certains diront que la variable nommée argumentCount est déclarée comme un int et qu’un Count ne peut pas être négatif, mais que vous pouvez avoir un int négatif {unsigned is better}.

Encore une fois, ce que c’est et comment il est utilisé vient jouer dans cette interprétation. Si c’est un compte, alors je suppose que ce ne serait jamais négatif. Après tout, comment pouvez-vous avoir un compte de -2 pommes? Je dirais, vous OWE deux pommes. Si c’est un numéro, je m’attendrais à ce qu’un cas négatif soit possible. C’est pourquoi le mot supplémentaire «of» est probablement important pour vous. Cela, et peut-être un nombre auquel fait référence une collection implique un élément spécifique plutôt qu’une propriété de la collection elle-même. Ie: argumentsNumber = 5 implique un argument spécifique mais pas nombreOfArguments.

main (int maxArgumentsIndex, arguments char **).

Ceci supprime l’ambiguïté. En l’appelant, un index supprime l’ambiguïté des cas négatifs et décrit également ce que c’est, et comment l’utiliser. Cela implique aussi par le libellé anglais qu’un max est un absolu et ressentirait un code d’écriture étrange qui modifie cette valeur (il devrait être const). «arguments» a du sens ici, car il est pluriel, décrit ce que c’est et comment il devrait déjà être utilisé. Même interpréter de cette manière peut être dangereux car un index est -1 d’un nombre / nombreOf. 5 arguments donnent un maxIndex de 4 !!

Toute autre fonction et j’utiliserais complètement:

fonction void (const unsigned int maxArgumentsIndex, const char ** arguments)

Toutes les situations ne méritent pas de longs descripteurs. En fait, parfois, une main courte donne plus de lisibilité, en particulier dans le cas de l’écriture de cours de mathématiques tels que Vec3f, Masortingx, Quaternion, etc. Je vais presque toujours essayer de faire correspondre le langage mathématique plutôt que linguistique. . float x, y, z vrs. float xComponent et autres.

Je comprends que tout cela est un choix de style, mais être conscient des choix aidera vraiment à long terme. Je garantis que les programmeurs aguerris sont dérangés lorsque les tableaux ne sont pas écrits au pluriel, mais encore une fois, main est une prose d’existence spéciale;)

Selon les normes C, oui, vous pouvez renommer, rien ne va avoir un impact. Comme je l’ai compris, en langage C, les noms de mots-clés / types / jetons par défaut ont été définis avec le but / l’utilisation, de la même manière que les noms sont définis.

 argc --> argument count argv --> argument vector 

ce qui est également logique en termes d’utilisation, donc vous pouvez changer pour n’importe quel nom attendez les Reserved names

Dans GCC, l’exécution du programme commence par le nom de la fonction main cela ne dépend pas de ses parameters.

Lorsque vous écrivez un programme autonome pour des microcontrôleurs, vous n’avez pas à vous soucier du nom main vous pouvez plutôt définir votre propre name et modifier le point d’entrée de l’assemblage pour pointer votre fonction. Cela dépend du compilateur du contrôleur et de la disponibilité du code source du contrôleur pré-défini. Je l’ai fait dans le contrôleur Freescale sous Code-warrior.

Ma note:

Il est préférable de suivre le style standard / code commun pour rendre le code plus visible et lisible

C’est sûr pour le compilateur.

Le seul problème que cela peut causer est la confusion. Les personnes qui lisent votre code s’attendent à ce que ces deux variables aient leurs noms standard. Vous pourriez même faire quelque chose comme ceci:

 int main(int foo, char ** bar) { int argc; float argv; 

Mais je ne pense pas avoir besoin de dire à quel point ce serait une mauvaise pratique.

Si vous n’aimez pas les noms de variables, pourquoi ne pas les remplacer par la macro #define :

 #define yourCounterName argc #define yourVectorName argv 

Vous ne prendrez aucun risque et produirez une “solution propre”.