Conseils utiles

Comment exécuter correctement le code C

Avant d'écrire notre premier programme C ++, nous devons connaître les exigences de base pour le code C ++, il n'y en a pas autant qu'il pourrait sembler à première vue. Voici la liste actuelle:

  • chaque commande se termine par un point-virgule ,,
  • il ne peut y avoir aucun espace dans les noms de commandes et autres instructions, ni commencer par des nombres,
  • C ++ est sensible à la casse. CODE, CoDe et le code peuvent effectuer des tâches complètement différentes,

Ce sont les règles principales sur lesquelles est basé le fondement de la programmation en C ++.

2. Les règles peuvent être enfreintes si elles suscitent des objections personnelles.

Ceci est une tentative pour créer un ensemble de recommandations générales sans imposer un style uniforme à tout le monde. Les programmeurs expérimentés personnalisent généralement le style de toute façon. Une telle liste de recommandations (ou du moins l'obligation de s'y familiariser) amène généralement les gens à réfléchir au style de programmation et à évaluer leurs propres pratiques dans ce domaine.

Les programmeurs débutants et inexpérimentés, par contre, utilisent généralement des directives de style pour mieux comprendre le jargon des programmeurs.

9. Les abréviations et acronymes des noms doivent être en minuscules.

L'utilisation de majuscules peut entraîner un conflit de nom, comme décrit ci-dessus. Sinon, les variables auraient les noms dVD, hTML, etc., ce qui n’est pas lisible. Un autre problème a déjà été décrit ci-dessus, lorsque le nom est associé à un autre, la lisibilité diminue, le mot suivant l'abréviation ne ressort pas comme il se doit.

11. Les membres de la classe avec le modificateur private doivent se voir attribuer le suffixe-underscore.

Outre le nom et le type, scope est la propriété la plus importante d'une variable. Spécifier explicitement un modificateur d'accès en tant que soulignement élimine la confusion entre les membres de la classe et les variables locales. Ceci est important car les variables de classe sont plus importantes que les variables de méthodes et doivent être traitées avec plus de soin.

Un effet supplémentaire du suffixe de soulignement est de résoudre le problème de nommage dans les méthodes qui définissent des valeurs, ainsi que dans les constructeurs:

Le problème est qu’il existe deux options de soulignement: la forme d’un suffixe et la forme d’un préfixe. Les deux options sont largement utilisées, mais la première option est recommandée car elle offre une meilleure lisibilité. Il convient de noter que la définition du modificateur d'accès pour les variables est parfois discutable. Bien qu'il semble que la pratique recommandée gagne des supporters et devienne plus courante parmi les professionnels.

12. Les variables personnalisées doivent avoir le même nom que leur type.

void setTopic (topic * topic) // NE PAS FAIRE: void setTopic (topic * value)
// NE PAS FAIRE: annuler setTopic (Topic * aTopic)
// NE PAS FAIRE: annuler setTopic (Topic * t)

void connect (base de données * base de données) // NE PAS: void connect (base de données * db)
// NE PAS: annuler la connexion (Database * oracleDB)

Réduisez la complexité en réduisant le nombre de termes et de noms utilisés. Simplifie également la reconnaissance de type simplement par nom de variable.

Si, pour une raison quelconque, cette recommandation semble inappropriée, cela signifie que le nom du type n'est pas choisi correctement.

Les variables non personnalisées peuvent être nommées en fonction de leur objectif et de leur type:

14. Les variables de grande portée doivent être appelées noms longs, avec une petite portée - courte.

Les noms des variables temporaires utilisées pour stocker les valeurs temporaires ou les index sont préférables. Un programmeur qui lit de telles variables devrait pouvoir supposer que leurs valeurs ne sont pas utilisées en dehors de plusieurs lignes de code. Ce sont généralement les variables i, j, k, l, m, n (pour les entiers), ainsi que c et d (pour les caractères).

31. Les constantes dans les énumérations peuvent avoir un préfixe - un nom de type commun.

Cela donne des informations supplémentaires sur l'emplacement de la déclaration, sur les constantes décrites dans une liste et sur les constantes de concept.

Une autre approche consiste à appeler des constantes selon leur type commun: Color :: RED, Airline :: AIR_FRANCE, etc.

Notez que le nom de l'énumération est généralement singulier, par exemple: enum Color <. > Le nom au pluriel a l’air agréable lorsqu’il est annoncé, mais ne convient pas à une utilisation pratique.

39. L’incomplétude des lignes brisées devrait être évidente.

totalSum = a + b + c +
d + e

fonction (param1, param2,
param3),

setText ("Long line split"
"en deux parties"),

pour (int tableNo = 0, tableNo

Un saut de ligne apparaît lorsque la limite de 80 colonnes décrite ci-dessus est dépassée. Il est difficile de définir des règles de ventilation strictes, mais les exemples ci-dessus illustrent des principes généraux.

  • point décimal
  • pause après l'opérateur,
  • alignement d'une nouvelle ligne avec le début de l'expression sur la ligne précédente.

Espaces et tirets

Entretoises séparées par des espaces:

Placez des espaces entre opérateurs et opérandes:

Lorsque la ligne dépasse 100 caractères, divisez-la en deux pour créer une nouvelle ligne après l'instruction et continuez à écrire:

Laissez des lignes vides entre les fonctions et entre les groupes d'expressions:

49. Les variables de classe ne doivent pas être déclarées comme publiques.

Ces variables violent les principes de la dissimulation et de l'encapsulation d'informations. Utilisez plutôt des variables avec le modificateur private et les fonctions d'accès correspondantes. Une exception est une classe sans comportement, pratiquement une structure de données (équivalente aux structures de langage C). Dans ce cas, il est inutile de masquer ces variables.

Veuillez noter que les structures en C ++ sont laissées uniquement pour la compatibilité avec C, leur utilisation nuit à la lisibilité du code. Utilisez des classes au lieu de structures.

53. Les comparaisons implicites de variables booléennes (logiques) et de pointeurs nuls doivent être évitées.

La norme C ++ ne garantit pas que les valeurs des variables int et float égales à zéro seront représentées par un 0 binaire. De plus, avec une comparaison explicite, le type comparé est visible.

Il serait logique de supposer que les pointeurs ne doivent pas non plus être implicitement comparés à zéro, par exemple if (line == 0) au lieu de if (line). Ce dernier est une pratique très courante en C / C ++, il peut donc également être utilisé.

57. Les boucles Do-While peuvent être évitées.

De tels cycles sont moins lisibles car la condition est décrite après le corps. Le lecteur devra parcourir tout le cycle pour comprendre son travail.

Les boucles Do-While ne sont pas du tout une nécessité absolue. Une telle boucle peut être remplacée par une boucle while ou for.

Moins de conceptions utilisées améliorent la lisibilité.

61. Évitez strictement les slogans complexes. Entrez des variables booléennes à la place.

bool isFinished = (elementNo maxElement),
bool isRepeatedEntry = elementNo == lastElement,
if (isFinished || isRepeatedEntry) <
:
>

// PAS:
if ((elementNo maxElement) ||
elementNo == lastElement) <
:
>

La définition de variables booléennes pour les expressions conduira à l'autodocumentation du programme. La conception sera plus facile à lire, à déboguer et à entretenir.

66. Les constantes à virgule flottante doivent être écrites avec un point décimal et au moins une décimale.

double total = 0.0, // NON RECOMMANDÉ: double total = 0,
double vitesse = 3.0e8, // NON RECOMMANDÉ: double vitesse = 3e8,

double somme,
:
somme = (a + b) * 10,0,

Cela met l'accent sur diverses approches lorsqu'il s'agit de nombres entiers et de nombres à virgule flottante. Du point de vue des mathématiques, ces deux modèles sont complètement différents et incompatibles.

Et aussi (comme le montre le dernier exemple ci-dessus), l'accent est mis sur le type de variable (somme) dans un endroit où cela n'est pas évident.

72. Les blocs de code doivent être conçus comme dans l'exemple 1 (recommandé) ou dans l'exemple 2, mais en aucun cas pas comme dans l'exemple 3. La conception des fonctions et des classes doit suivre l'exemple 2.

tandis que (! fait) <
quelque chose (),
done = moreToDo (),
>

alors que (fait)
<
quelque chose (),
done = moreToDo (),
>

alors que (fait)
<
quelque chose (),
done = moreToDo (),
>

L'exemple 3 utilise des marges supplémentaires, ce qui empêche un affichage clair de la structure logique du code.

75. La structure if-else devrait être structurée comme suit:

si (condition) <
des déclarations
>

si (condition) <
des déclarations
>
sinon <
des déclarations
>

si (condition) <
des déclarations
>
sinon si (condition) <
des déclarations
>
sinon <
des déclarations
>

Corollaire de la règle ci-dessus. De plus, l'écriture d'autre chose sur la même ligne où se trouve l'accolade fermante du premier bloc n'est pas interdite:

Il est préférable de placer chaque partie de if-else sur une ligne distincte. Cela simplifie les opérations de code, telles que le déplacement du bloc else.

80. Le commutateur doit être conçu comme suit:

commutateur (condition) <
cas ABC:
des déclarations
// "pause" manquante

affaire DEF:
des déclarations
pause

cas XYZ:
des déclarations
pause

Notez que chaque mot de la casse est en retrait par rapport à la construction entière, ce qui aide à le mettre en évidence. Notez également les espaces avant les deux points. Si le mot clé break manque quelque part, un commentaire doit servir d'avertissement. Les programmeurs oublient souvent de mettre ce mot, aussi le cas d'omission délibérée devrait-il être décrit de manière spécifique.

84. Lacunes

  • Les opérateurs doivent être éliminés avec des espaces.
  • Après les mots-clés C ++ réservés, un espace doit être laissé.
  • Vous devez mettre des espaces après les virgules.
  • Les deux points doivent être éliminés avec des espaces.
  • Après les points-virgules dans la boucle for, vous devez insérer des espaces.

a = (b + c) * d, // NON RECOMMANDÉ: a = (b + c) * d

while (true) // NON RECOMMANDÉ: while (true)
<
.

doQuelque chose (a, b, c, d), // NON RECOMMANDÉ: doQuelque chose (a, b, c, d),

cas 100: // NON RECOMMANDÉ: cas 100:

Met en évidence les parties individuelles des expressions. Améliore la lisibilité. Il est difficile de donner un ensemble complet de recommandations concernant les espaces en C ++. Les recommandations ci-dessus devraient indiquer les principes généraux.

85. Un espace peut suivre un nom de méthode si un autre nom suit.

Mettez en surbrillance les noms uniques. Améliore la lisibilité. S'il n'y a pas d'autre nom, vous pouvez omettre l'espace (doQuelque chose ()).

Une autre approche consiste à spécifier un espace immédiatement après la parenthèse ouvrante. Ceux qui l'utilisent mettent aussi généralement un espace devant la parenthèse fermante: doQuelque chose (currentFile),. Cela vous permet de mettre en surbrillance des noms individuels, l'espace avant la parenthèse fermante n'a pas l'air naturel, mais sans cela l'expression est asymétrique (doQuelquechose (currentFile),).

89. Utilisez l’alignement partout où il améliore la lisibilité.

if (a == lowValue) compueSomething (),
else if (a == mediumValue) computeSomethingElse (),
else if (a == highValue) computeSomethingElseYet (),

valeur = (potentielle * densité d'huile) / constante1 +
(profondeur * densité de l'eau) / constant2 +
(zCoordinateValue * gasDensity) / constant3,

minPosition = computeDistance (min, x, y, z),
averagePosition = computeDistance (moyenne, x, y, z),

commutateur (valeur) <
case PHASE_OIL: strcpy (phase, "Oil"), pause,
case PHASE_WATER: strcpy (phase, "Water"), pause,
case PHASE_GAS: strcpy (phase, "Gas"), pause,
>

Il existe de nombreux cas où le code peut être encore aligné, même s'il enfreint les règles établies précédemment.

94. Les commentaires sur les classes et les en-têtes de méthodes doivent être conformes aux conventions JavaDoc.

Les programmeurs Java utilisent une approche plus développée de la documentation grâce à l'outil automatisé standard Javadoc, qui fait partie du package de développement et permet de créer automatiquement une documentation au format HTML à partir de commentaires en code.

Il existe des outils similaires en C ++. Ils respectent les mêmes conventions de syntaxe que JavaDoc (voir, par exemple, Doc ++ ou Doxygen).

Noms et variables

Donnez aux variables des noms descriptifs tels que firstName ou homeworkScore. Évitez les noms à lettre unique tels que x ou c, sauf pour les itérateurs tels que i.

Nommez les variables et les fonctions à l'aide du registre de chameaux. Appelez les classes PascalRegister et les constantes dans UPPER_REG. Vous pouvez en apprendre plus sur l'affaire Camel dans cet article.

Si une variable est utilisée uniquement dans un if spécifique, rendez-la locale en la déclarant dans le même bloc de code et non pas globale.

SmartDec, Moscou, de 60 000 à 250 000

Choisissez le type de données approprié pour vos variables. Si la variable ne contient que des entiers, définissez-la comme étant int et non double.

Utilisez une chaîne de texte standard pour C ++ plutôt que pour C. C ++ confond avec le fait qu'il possède deux types de chaînes de texte: la classe string de C ++ et l'ancien char * (character array) de C:

Si une certaine constante est souvent utilisée dans votre code, spécifiez-la comme constante et faites toujours référence à cette constante, pas à sa valeur:

Ne jamais déclarer une variable globale mutable. Les variables globales ne doivent être que des constantes. Au lieu de rendre la valeur globale, faites-en un paramètre et renvoyez la valeur si nécessaire:

Expressions C ++ basiques

C ++ est basé sur C, il existe donc toujours une option pour résoudre le problème «par C ++» et «par C». Par exemple, lorsque vous souhaitez exporter quelque chose sur la console système, vous pouvez le faire “à la manière C ++” à l'aide de l'opérateur de sortie cout, alors que “à la manière C” vous utiliseriez une fonction globale telle que printf:

Trouvez-vous souvent difficile de choisir entre pour et pendant longtemps? Utilisez la boucle for lorsque vous connaissez le nombre de répétitions et la boucle while lorsque le nombre de répétitions est inconnu:

Lorsque vous utilisez des opérateurs de contrôle tels que if / else, for, while, utilisez toujours <> et l'indentation correspondante, même si le corps de l'instruction de contrôle complète est constitué d'une seule ligne:

Essayez d'éviter d'utiliser des expressions break ou continue. Utilisez-les seulement si absolument nécessaire.

C ++ a une fonction de sortie qui quitte le programme immédiatement. Il est fortement déconseillé d'utiliser cette fonctionnalité. Un programme doit toujours se terminer naturellement en atteignant l'état de retour de main.

En utilisant les expressions if / else, choisissez entre différents modèles if et else en fonction des conditions qui sont liées. Éviter inutile si tests:

Si vous avez une instruction if / else qui renvoie un booléen, renvoyez les résultats du test directement:

Ne vérifiez jamais les valeurs booléennes avec == ou! = Avec true ou false:

Excès

Si vous utilisez le même code deux fois ou plus, trouvez un moyen de supprimer le code redondant afin d'éviter sa répétition. Par exemple, il peut être placé dans une fonction auxiliaire. Si le code répété est similaire, mais pas tout à fait, essayez de créer une fonction d'assistance qui prend des paramètres et représente la partie différente:

Déplacez le code générique de l'instruction if / else pour qu'il ne se répète pas:

Commentaires

Titre Commentaire. Publiez un commentaire en-tête décrivant la fonction du fichier en haut de chaque fichier. Supposons que le lecteur de votre commentaire soit un programmeur expérimenté, mais pas quelqu'un qui ait déjà vu votre code auparavant.

En-tête de fonction / constructeur. Placez un commentaire d'en-tête sur chaque constructeur et fonction de votre fichier. L'en-tête doit décrire le comportement et / ou l'objectif de la fonction.

Paramètres / Retour. Si votre fonction accepte les paramètres, décrivez brièvement leur objectif et leur signification. Si votre fonction renvoie une valeur, décrivez brièvement ce qu’elle renvoie.

Les exceptions. Si votre fonction lève intentionnellement des exceptions pour certains cas d'erreur, vous devez le mentionner.

Commentaires sur une seule ligne. S'il y a une section de code dans la fonction qui est longue, complexe ou incompréhensible, décrivez-en brièvement l'objectif.

Todo. Vous devez supprimer tous les commentaires // TODO avant de terminer et de soumettre le programme.

Fonctions et conception procédurale

Une fonction bien conçue présente les caractéristiques suivantes:

  • Effectue pleinement une tâche clairement définie,
  • Ne prend pas trop de travail
  • Pas connecté avec d'autres fonctions sans but,
  • Stocke les données aussi compressées que possible,
  • Aide à reconnaître et à partager la structure du programme,
  • Aide à éliminer les excédents qui seraient autrement présents dans le programme.

Utilisez des paramètres pour envoyer des informations à partir d'une fonction ou lorsqu'une fonction doit renvoyer plusieurs valeurs. Ne pas utiliser les paramètres inutilement. Notez que a, b et c ne sont pas des paramètres dans la fonction ci-dessous, car ce n'est pas nécessaire:

Lorsque vous souhaitez renvoyer une valeur d'une fonction, utilisez la valeur de retour:

Lors de l'envoi d'un objet à une fonction en tant que paramètre, vous devez le transmettre par référence, car s'il est passé en tant que valeur, l'objet entier sera copié. Copier des objets coûte cher.

Utilisez des variables de référence, pas des pointeurs. Une des raisons est que les variables de référence, contrairement aux pointeurs, ne peuvent pas être NULL:

Si vous transmettez un objet à une fonction et que le code ne modifie pas l'apparence de l'objet, transmettez-le en tant que référence const:

Évitez les appels en chaîne lorsque plusieurs fonctions s'appellent dans une chaîne sans renvoyer de valeur à main. Assurez-vous que main est une brève description de l’ensemble du programme:

Conception de la classe

Encapsulation. Séparez vos objets en rendant tous les champs de données de votre classe privés:

.h vs .cpp. Placez toujours les déclarations de classe et de pièce dans vos propres fichiers, ClassName.h. Toujours réduire les fichiers de déclaration de classe .h dans le bloc de préprocesseur #ifndef / define / endif pour éviter plusieurs déclarations de la même classe:

classe vs struct. Utilisez toujours la classe uniquement si vous ne créez pas une forme de données très petite et simple qui ne nécessite que quelques variables publiques et éventuellement un constructeur pour les initialiser.

Eviter les champs inutiles. Utilisez des champs pour stocker des données importantes sur vos objets, mais pas des valeurs temporaires utilisées une fois.

Comment Yandex utilise vos données et votre apprentissage automatique pour personnaliser des services - lisez et regardez YaC 2019.