Qu'est-ce qu'une bonne convention de nommage pour vars, méthodes, etc. en C++?
Je viens d'un monde Objective-C et Cocoa où il y a beaucoup de conventions et beaucoup de gens diront que cela rend votre code plus beau!.
Le C++ standard n'a probablement pas la même chose que ci-dessus, mais j'espère pouvoir m'en tenir à certains autres SDK ou API (comme les conventions de Microsoft (?), Etc.).
J'espère que vous pourrez me fournir des liens.
Faites ce que vous voulez tant que son minimum, cohérente et ne pas enfreindre les règles .
Personnellement, je trouve le style Boost plus facile; il correspond à la bibliothèque standard (donnant un aspect uniforme au code) et est simple. Je cloue personnellement sur les préfixes m et p aux membres et aux paramètres, respectivement, en donnant:
#ifndef NAMESPACE_NAMES_THEN_PRIMARY_CLASS_OR_FUNCTION_THEN_HPP
#define NAMESPACE_NAMES_THEN_PRIMARY_CLASS_OR_FUNCTION_THEN_HPP
#include <boost/headers/go/first>
#include <boost/in_alphabetical/order>
#include <then_standard_headers>
#include <in_alphabetical_order>
#include "then/any/detail/headers"
#include "in/alphabetical/order"
#include "then/any/remaining/headers/in"
// (you'll never guess)
#include "alphabetical/order/duh"
#define NAMESPACE_NAMES_THEN_MACRO_NAME(pMacroNames) ARE_ALL_CAPS
namespace lowercase_identifers
{
class separated_by_underscores
{
public:
void because_underscores_are() const
{
volatile int mostLikeSpaces = 0; // but local names are condensed
while (!mostLikeSpaces)
single_statements(); // don't need braces
for (size_t i = 0; i < 100; ++i)
{
but_multiple(i);
statements_do();
}
}
const complex_type& value() const
{
return mValue; // no conflict with value here
}
void value(const complex_type& pValue)
{
mValue = pValue ; // or here
}
protected:
// the more public it is, the more important it is,
// so order: public on top, then protected then private
template <typename Template, typename Parameters>
void are_upper_camel_case()
{
// gman was here
}
private:
complex_type mValue;
};
}
#endif
That . (Et comme je l'ai dit dans des commentaires, le pas adopte le Guide de rédaction de Google pour votre code, sauf s'il s'agit d'un paramètre aussi peu important que la convention de dénomination.)
Il y a probablement autant de conventions de nommage que d'individus, le débat étant aussi sans fin (et stérile) quant au style de support à utiliser, etc.
Je vais donc avoir 2 conseils:
- être cohérent dans un projet
- n'utilisez pas d'identifiants réservés (tout ce qui comporte deux traits de soulignement ou commençant par un trait de soulignement suivi d'une lettre majuscule)
Le reste dépend de toi.
En fait, j'utilise souvent le style Java: PascalCase pour les noms de type, camelCase pour les fonctions et les variables, CAPITAL_WORDS pour les macros de préprocesseur. Je préfère cela par rapport aux conventions Boost/STL car vous n'avez pas besoin de suffixer les types avec _type. Par exemple.
Size size();
au lieu de
size_type size(); // I don't like suffixes
Cela présente l'avantage supplémentaire que le formateur de code StackOverflow reconnaît Size comme nom de type ;-)
Nous suivons les indications figurant sur cette page: Directives de style de programmation C++
Je vous recommande également de lire Les éléments de style C++ de Misfeldt et al , qui est un excellent livre sur ce sujet.
Pour aborder la question plus générale des guides de style, je suggère de choisir l'un d'entre eux et de le respecter.
Le Guide de style de Google est très détaillé/complet, c'est donc un bon choix.
Une convention commune juste pour nommer est:
camelCasepour tous les noms (sauf les constantes).- Commençant par une capitale si c'est une classe.
- Minuscule sinon.
- Constantes dans
ALL_CAPSavec soulignement séparant les travaux. - Les fonctions peuvent être écrites de la même manière que les variables,
camelCase(vous pouvez dire que c'est une fonction car elle nécessite()après celle-ci). - Et les variables membres préfixées avec une
met seraient donc écritesmCamelCase.
C’est vraiment à vous de choisir, ou bien les personnes pour lesquelles vous travaillez/avec l’université dans laquelle vous étudiez.
Pour plus de détails sur une variété de guides de style/motifs sous-jacents, consultez Pragmatic Programmer de Andrew Hunt et David Thomas.
Pour ce que cela vaut, Bjarne Stroustrup, l'auteur original de C++ a son propre style préféré, décrit ici: http://www.stroustrup.com/bs_faq2.html
Tandis que beaucoup de gens suggéreront plus ou moins strictement la notation hongroise variants ( effrayant !), Pour les suggestions de nom, je vous suggérerais de jeter un coup d'œil à Règles de codage Google C++ . Ce ne sont peut-être pas les conventions de dénomination les plus populaires, mais au moins, elles sont assez complètes. Hormis les conventions de nommage sonores, il existe quelques directives utiles, mais vous devez en prendre une bonne partie (interdiction des exceptions, par exemple, et tendance à s’éloigner du style de codage C++ moderne).
Personnellement, j’aime bien le style de convention extrêmement basse technologie de STL et de Boost;).
la cohérence et la lisibilité (code auto-documenté) sont importantes. certains indices (tels que le cas) peuvent et doivent être utilisés pour éviter les collisions et indiquer si une instance est requise.
l’une des meilleures pratiques que j’ai eue est l’utilisation de formateurs de code (astyle et uncrustify en sont deux exemples). Les formateurs de code peuvent détruire le formatage de votre code - configurez le formateur et laissez-le faire son travail. sérieusement, oubliez le formatage manuel et commencez à les utiliser. ils vont économiser une tonne de temps.
comme mentionné, soyez très descriptif avec nommer. soyez également très spécifique avec la portée (types de classe/données/espaces de nom/espaces de nom anonymes). En général, j'aime beaucoup la forme écrite courante de Java - c'est une bonne référence et similaire au c ++.
en ce qui concerne l'apparence/nom spécifique, il s'agit d'un petit échantillon similaire à ce que j'utilise (les variables/arguments sont lowerCamel et cela ne montre qu'une partie des fonctionnalités du langage):
/** MYC_BEGIN_FILE_ID::FD_Directory_nanotimer_FN_nanotimer_hpp_::MYC_BEGIN_FILE_DIR::Directory/nanotimer::MYC_BEGIN_FILE_FILE::nanotimer.hpp::Copyright... */
#ifndef FD_Directory_nanotimer_FN_nanotimer_hpp_
#define FD_Directory_nanotimer_FN_nanotimer_hpp_
/* typical commentary omitted -- comments detail notations/conventions. also, no defines/macros other than header guards */
namespace NamespaceName {
/* types prefixed with 't_' */
class t_nanotimer : public t_base_timer {
/* private types */
class t_thing {
/*...*/
};
public:
/* public types */
typedef uint64_t t_nanosecond;
/* factory initializers -- UpperCamel */
t_nanotimer* WithFloat(const float& arg);
/* public/protected class interface -- UpperCamel */
static float Uptime();
protected:
/* static class data -- UpperCamel -- accessors, if needed, use Get/Set prefix */
static const t_spoke Spoke;
public:
/* enums in interface are labeled as static class data */
enum { Granularity = 4 };
public:
/* construction/destruction -- always use proper initialization list */
explicit t_nanotimer(t_init);
explicit t_nanotimer(const float& arg);
virtual ~t_nanotimer();
/*
public and protected instance methods -- lowercaseCamel()
- booleans prefer is/has
- accessors use the form: getVariable() setVariable().
const-correctness is important
*/
const void* address() const;
virtual uint64_t hashCode() const;
protected:
/* interfaces/implementation of base pure virtuals (assume this was pure virtual in t_base_timer) */
virtual bool hasExpired() const;
private:
/* private methods and private static data */
void invalidate();
private:
/*
instance variables
- i tend to use underscore suffix, but d_ (for example) is another good alternative
- note redundancy in visibility
*/
t_thing ivar_;
private:
/* prohibited stuff */
explicit t_nanotimer();
explicit t_nanotimer(const int&);
};
} /* << NamespaceName */
/* i often add a multiple include else block here, preferring package-style inclusions */
#endif /* MYC_END_FILE::FD_Directory_nanotimer_FN_nanotimer_hpp_ */
Il existe de nombreux styles/conventions différents utilisés par les utilisateurs lorsqu'ils codent en C++. Par exemple, certaines personnes préfèrent séparer les mots à l'aide de majuscules (myVar ou MyVar) ou de traits de soulignement (my_var). En règle générale, les variables qui utilisent des traits de soulignement sont en minuscules (d'après mon expérience).
Il existe également un style de codage appelé hongrois, qui, je crois, est utilisé par Microsoft. Personnellement, je pense que c'est une perte de temps, mais cela peut s'avérer utile. C’est là que les noms de variables reçoivent des préfixes courts tels que i ou f pour indiquer le type de variable. Par exemple: int iVarname, char * strVarname.
Il est accepté que vous terminiez un nom de structure/classe avec _t, afin de le différencier d'un nom de variable. Par exemple.:
class cat_t {
...
};
cat_t myCat;
Il est également généralement accepté d’ajouter un affixe pour indiquer des pointeurs, tels que pVariable ou variable_p.
Au total, il n'y a pas vraiment de simple standard, mais beaucoup. Les choix que vous faites pour nommer vos variables importent peu, dans la mesure où ils sont compréhensibles et surtout cohérents. Cohérence, consistance, CONSISTANCE! (essayez de taper cela trois fois!)
Et si tout échoue, google le.
Cela n'a pas d'importance. Assurez-vous simplement de nommer vos variables et fonctions de manière descriptive. Aussi être cohérent.
Maintenant pire que de voir un code comme celui-ci:
int anInt; // Great name for a variable there ...
int myVar = Func( anInt ); // And on this line a great name for a function and myVar
// lacks the consistency already, poorly, laid out!
Edit: Comme l’a souligné mon commentateur, la cohérence de l’ensemble de l’équipe doit être préservée. En tant que telle, la méthode WHAT que vous avez choisie importe peu, tant que cette cohérence est maintenue. Il n'y a pas de bonne ou de mauvaise méthode, cependant. Chaque équipe dans laquelle j'ai travaillé a eu des idées différentes et je me suis adapté à celles-ci.
pas aussi concis que le lien que vous avez fourni: mais les chapitres suivants 14 - 24 peuvent aider :) hehe