Suis-je immoral pour avoir utilisé un nom de variable qui ne diffère de son type que par cas?

95

Par exemple, prenez ce morceau de code:

var person = new Person();

ou pour vous les Pythonistes:

person = Person()

On me dit constamment à quel point c'est mauvais, mais je n'ai pas encore vu d'exemple de l'immoralité de ces deux lignes de code. Pour moi, une personne est une personne et essayer de lui donner un autre nom est une perte de temps. Je suppose que dans les jours qui ont précédé la coloration syntaxique, cela aurait été un gros problème. Mais ces jours-ci, il est assez facile de distinguer un nom de type d'un nom de variable. Heck, il est même facile de voir la différence ici sur SO.

Ou y a-t-il quelque chose qui me manque? Si tel est le cas, il serait utile que vous fournissiez un exemple de code qui pose des problèmes.

Jason Baker
la source
Je me suis toujours posé des questions à ce sujet. Bonne question!
William Brendel
18
Appeler une personne est simplement cruel. Quel est le problème avec "bob"?
Sam Meldrum
17
N'oublions pas avant var il y avait la beauté zen de Person person = new Person ();
Jamie Ide
1
@Jamie appelez-vous la saisie statique zen?
orokusaki
Je voudrais aller encore plus loin dans cette question: est-il incontestablement mal de faire Person Person=new Person();à ce sujet? Comme indiqué dans The Question, nous vivons à une époque où la mise en évidence de la syntaxe et la reconnaissance du contexte sont si incroyables que mon compilateur ne s'est jamais plaint que je fasse exactement cela. J'adore mes variables CamelCased - pourquoi ne le devrais-je pas (dans des situations où il Person Persony a une instanciation générale et unique de la classe et aucun conflit n'est présent ni possible)?
Robert Synoradzki

Réponses:

94

Quel est le raisonnement de ceux qui vous disent que c'est mauvais? Je le fais tout le temps. C'est le moyen le plus simple et expressif de nommer une seule variable d'un type. Si vous aviez besoin de deux Personobjets, vous pourriez préfixer personavec des adjectifs significatifs comme

fastPerson
slowPerson

sinon juste

person

ça me va.

Andrew Hare
la source
8
"Quel est le raisonnement de ceux qui vous disent que c'est mauvais?" - Je sais pas. C'est pourquoi j'ai commencé ce sujet. :-)
Jason Baker
De toute évidence, vous n'avez jamais eu à entrer dans le code de quelqu'un d'autre. Je sais que lorsque je suis appelé à rechercher un bogue récemment découvert dans un code vieux de plusieurs années par un programmeur qui a quitté l'entreprise depuis longtemps - tout ce qui empêche de me développer est le temps de ne pas résoudre le problème. Si l'un de ces obstacles essaie de comprendre ce qu'est une instance et ce qu'est une classe simplement parce qu'un programmeur ne peut pas être dérangé de dire "var currentPerson = New Person ();" alors c'est du temps inutile, perdu. ... et lorsque vos clients attendent une solution, le temps presse.
David le
3
@David - Vous m'avez attrapé! Je savais que le codage dans le vide ferait apparaître sa vilaine tête tôt ou tard :) Sérieusement cependant - j'ai du mal à croire que vous soyez trébuché en étant incapable de discerner entre les types et leurs instances en fonction de cette convention de dénomination.
Andrew Hare le
2
@David - cela devrait être le problème de l'outil d'analyse de code. C'est aussi pourquoi il existe une convention selon laquelle les types commencent par une lettre majuscule en Python.
ilya n.
69

J'utilise beaucoup ce modèle dans les signatures de méthode. Si je suis incapable de fournir un autre nom descriptif, alors à mon humble avis, il n'y a rien de mal à cela.

Ce qui ne va pas, ce serait si vous avez deux types de personne et de personne, alors c'est très très faux.

JoshBerke
la source
1
«Ce qui ne va pas, ce serait si vous avez deux types de personne et de personne, alors c'est très très faux. - Cela a un sens pour moi.
Jason Baker
1
Si votre création d'une API VB ne pourrait pas gérer le code car il est insensible à la casse.
JoshBerke
1
Hé, dans le cas d'une API, vous vous souciez des noms de méthodes ou des propriétés publiques, pas des noms de variables, car ces derniers ne seront pas exposés au code client. Quant à la question de Jason, j'utilise moi aussi cette dénomination tout le temps. Absolument rien de mal à cela.
Frederick The Fool
1
Exactement mon point Frederick pourquoi avoir deux types qui ne diffèrent que le cas de base est une mauvaise idée ;-)
JoshBerke
1
Même si ce n'est pas faux, cela rend le code plus difficile à lire. La lisibilité compte également.
J3r3myK
45

Je l'utilise tout le temps pour les références d'objets temporaires. Je l'éviterais comme le fléau des types de données primitifs.

Person person = new Person(); // okay

int Int = 42; // pure evil
Bill le lézard
la source
S'il n'y avait vraiment pas de signification sémantique, je pourrais donner une primitive, j'utiliserais i ou s, à part les indices de boucle, je ne peux penser à aucun autre scénario de ce genre.
AnthonyWJones
1
Je recommanderais de ne pas utiliser i, surtout si vous écrivez du code avec une boucle. i est presque universellement considéré comme un nom de variable de boucle.
Jason Baker
3
D'accord. Un nom de variable à une lettre crie «Je suis temporaire». Les indices de boucle doivent être i, j, k, tous les autres doivent être a, b, c, x, y, z ou toute autre lettre qui ne peut être confondue avec autre chose, comme l et o.
Bill the Lizard
Bravo! 42, c'est tout simplement trop. :)
Vishal Seth
18

Si quelqu'un dit que c'est mal, demandez-lui si c'est mieux:

var abc = new Person();
Chris
la source
2
@Chris: exactement! Ou mieux encore: var temp = new Person();(Clause de non-responsabilité: je sais qu'il y a vraiment des endroits pour une fois utiliser des variables temporaires, mais aussi souvent que pas quand je vois cela dans le code de quelqu'un, l'auteur n'a tout simplement jamais recommencé à donner au var un nom approprié et cela peut ainsi être "abc".)
Dinah
15

Si la personne est une personne générale dans le contexte, alors «personne» est un très bon nom. Bien sûr, si la personne a un rôle spécifique dans le code, il est préférable de la nommer en utilisant le rôle.

PEZ
la source
9

Je suppose que je vais être critiqué pour l'avoir dit, mais ...

Ayant juste traversé un siècle d'assassinat épique et de cupidité, nous, les programmeurs, sommes vraiment bénis si la chose la plus immorale que nous puissions faire est de nommer une variable.

Mike Dunlavey
la source
6
Sinon, si les décisions morales que nous pouvons prendre sont d'une telle insignifiance, nous sommes maudits. Je ne suis pas sûr de vouloir que mon éloge funèbre se concentre sur mon style de codage. J'aimerais au moins une mention passagère du fait que je fais partie d'une famille.
David Thornley
1
@David: Encore une fois. Avec mon premier petit-enfant sur le chemin, je suppose que c'est banal, mais je me soucie du genre de monde que nous transmettons.
Mike Dunlavey
8

Je ne pense pas que ce soit nécessairement «mauvais», mais évidemment si vous pouvez le qualifier pour lui donner plus de contexte, comme quel genre de personne il s'agit (vous avez affaire à une seule des personnes probablement possibles), alors quelqu'un d'autre le choisit up peut mieux comprendre.

Tim Amande
la source
6

Jason - Je ne sais pas qui vous a dit que c'était mauvais. Un certain nombre d'auteurs l'utilisent comme moyen standard d'exprimer une instance (minuscule) d'une classe (en majuscule).

J'utilise cela assez souvent car je trouve que la variable minuscule me communique en fait non seulement qu'il s'agit d'une instance mais aussi le nom de la classe.

À moins que quelqu'un ait un argument solide en faveur du contraire, je continuerai certainement à le faire.

Mark Brittingham
la source
6

La raison pour laquelle il est considéré comme mauvais est que si vous avez besoin d'avoir 2 personnes à l'avenir, vous pouvez alors vous retrouver avec un code qui ressemble à.

Personne personne = nouvelle personne ();

Personne person2 = nouvelle personne ();

Ce serait alors à la limite de "Bad". Cependant, dans ce cas, vous devez alors refactoriser votre personne d'origine afin de faire la distinction entre les deux.

Comme pour votre exemple, le nom de variable "personne" est un nom parfaitement descriptif pour l'objet "Personne". Il n'y a donc rien de mal à cela.

Jour de Robin
la source
3

Je dis nom pour ce que c'est: si la variable représente une personne avec 2 chiens, appelez-la personWith2Dogs . Si la variable a une portée courte (comme une boucle var), la personne va bien.

Blé Mitch
la source
3

J'utilise beaucoup cela dans mon code et je ne pense pas qu'il y ait quelque chose qui cloche. Cela dit, je ne l'utiliserais (probablement) pas dans une méthode plus longue que, disons, un écran, et s'il y a plusieurs instances de la classe Person. Ne les nommez certainement pas person1, person2, person3 ... utilisez plutôt quelque chose de plus descriptif, comme person_to_del, person_to_ban, person_to_update, etc.

kmelvn
la source
3

Pas immoral, mais une recherche globale trouvera les deux Personet personsi vous ne parvenez pas à activer la sensibilité à la casse. Je préfère un préfixe pour faciliter la recherche / remplacement global, mais absolument PAS le hongrois ou quelque chose de long / compliqué. Alors, j'utilise ...

Personpour la classe / type aPersonpour une variable locale thePersonpour un paramètre de méthode myPersonpour une variable d'instance ourPersonpour une variable de classe

En de rares occasions, je pourrais utiliser pdans un contexte local où j'ai BEAUCOUP de références, mais cela ne s'applique généralement qu'aux index de boucle et autres.

Rob Williams
la source
3

Ça dépend.

Si vous avez un style de capitalisation strict, donc les variables commencent en minuscules (et utilisez soit under_scores ou camelCase pour les sauts de mots), et les classes commencent par des majuscules, alors il est évident que personne est une variable et Person est une classe, et quand quelqu'un comprend cela , ils ne semblent pas se trouver dans des espaces de noms qui se chevauchent. (De même, les gens ne se confondent presque jamais entre le verbe ou le nom «polonais» et l'adjectif «polonais».)

Si vous n'avez pas un tel style, alors vous avez deux noms qui peuvent facilement être confondus et qui ne diffèrent que par casse. C'est mauvais.

David Thornley
la source
Salut encore David. Je ne me souviens pas si vous êtes celui qui a édité un de mes messages parce que j'avais écrit "pollish", ou était-ce "polish", alors que je voulais frotter quelque chose jusqu'à ce qu'il brille? Eh bien, je ne sais toujours pas ce qui est juste :-)
Mike Dunlavey
Je ne pense pas avoir fait une telle modification, donc c'était probablement quelqu'un d'autre. BTW, c'est "polonais".
David Thornley
2

Quels sont les arguments exacts que ces gens utilisent?

S'ils ne vous permettent pas d'utiliser la personne comme nom de variable, vous pouvez envisager d'ajouter le préfixe «a».

aPerson = Person()
Gerrie Schenck
la source
2
Ce serait pire, à mon avis. C'est plus difficile à lire et il ne fournit aucune information supplémentaire.
Joachim Sauer
Ouais mais au moins le nom est différent du nom de la classe, ce qu'ils veulent évidemment.
Gerrie Schenck
Ce serait suivre les lettres de la loi, mais certainement pas l'esprit.
Joachim Sauer le
1
+1, j'utilise thePerson pour les paramètres et myPerson pour les locaux que je gère.
Amy B
2

Je pense que ce que vous faites est bien. Je pense qu'en général, il est important d'avoir des normes de codage convenues.

Par exemple, j'utilise lowerCamelCase pour les instances, les variables et UpperCamelCase pour les classes, etc.

Les normes de codage devraient éliminer ce problème.

Quand je regarde des programmes open source réussis, ils ont souvent des normes de codage

http://drupal.org/coding-standards

http://help.joomla.org/content/view/826/125/

http://wiki.rubyonrails.org/rails/pages/CodingStandards

http://lxr.linux.no/linux/Documentation/CodingStyle

Accepter les normes de codage devrait être la dernière bataille que vous ayez à ce sujet.

En fait, regardez l'entrée wikipedia (de http://en.wikipedia.org/wiki/CamelCase )

Style de programmation et de codage

La capitalisation interne est parfois recommandée pour indiquer les limites des mots par les directives de style de codage pour l'écriture du code source (par exemple, le langage de programmation Mesa et le langage de programmation Java). Les recommandations contenues dans certaines de ces directives sont prises en charge par des outils d'analyse statique qui vérifient le code source pour la conformité.

Ces recommandations font souvent la distinction entre UpperCamelCase et lowerCamelCase, spécifiant généralement la variété à utiliser pour des types d'entités spécifiques: variables, champs d'enregistrement, méthodes, procédures, types, etc.

Un style de codage Java largement utilisé dicte que UpperCamelCase soit utilisé pour les classes, et lowerCamelCase pour les instances et les méthodes. [19] Reconnaissant cet usage, certains IDE, comme Eclipse, implémentent des raccourcis basés sur CamelCase. Par exemple, dans la fonction d'assistance de contenu d'Eclipse, taper uniquement les lettres majuscules d'un mot CamelCase suggérera un nom de classe ou de méthode correspondant (par exemple, taper «NPE» et activer l'assistance de contenu pourrait suggérer «NullPointerException»).

La notation hongroise originale pour la programmation spécifie qu'une abréviation minuscule pour le "type d'utilisation" (et non le type de données) doit précéder tous les noms de variables, le reste du nom étant en UpperCamelCase; en tant que tel, il s'agit d'une forme de lowerCamelCase. CamelCase est la convention officielle pour les noms de fichiers en Java et pour l'ordinateur personnel Amiga.

Microsoft .NET recommande lowerCamelCase pour les paramètres et les champs non publics et UpperCamelCase (alias "Pascal Style") pour les autres types d'identificateurs. [20]

Python recommande UpperCamelCase pour les noms de classes. [21]

Le registre NIEM exige que les éléments de données XML utilisent UpperCamelCase et les attributs XML utilisent lowerCamelCase.

Il n'y a pas de convention unique pour l'inclusion d'abréviations majuscules (principalement des acronymes et des initialismes) dans les noms CamelCase. Les approches incluent de laisser l'abréviation entière en majuscules (comme dans "useHTTPConnection") et de ne laisser que la première lettre en majuscules (comme dans "useHttpConnection").

L'étui Camel n'est en aucun cas universel en informatique. Les utilisateurs de plusieurs langages de programmation modernes, notamment ceux des familles Lisp et Forth, utilisent presque toujours des tirets. Parmi les raisons parfois invoquées, citons le fait que cela ne nécessite pas de changement sur la plupart des claviers, que les mots sont plus lisibles lorsqu'ils sont séparés et que la casse de chameau peut tout simplement ne pas être conservée de manière fiable dans les langues insensibles à la casse ou à casse (comme Common Lisp, qui, bien que techniquement un langage sensible à la casse, canonise (plie) les identifiants en majuscules par défaut).

Stewart Robinson
la source
2

Il est possible de faire valoir avec plus de force que les noms de méthodes de ce type sont non seulement inoffensifs, mais peuvent également être un indicateur de code de bonne qualité.

  • Un indicateur d'une bonne granularité du code: si vos méthodes sont courtes, à usage unique et nommées de manière descriptive, vous n'avez pas besoin de beaucoup d'informations dans les noms de variables. Si vous avez de longues méthodes qui font beaucoup de choses et que vous avez besoin de garder une trace de beaucoup de contexte et d'état, alors vos noms de variables doivent être plus descriptifs.

  • Un indicateur des calculs à usage général poussés vers des méthodes à usage général: si vous effectuez une manipulation intermédiaire des structures de données dans une méthode métier, par exemple un tableau d'utilisateurs doit être dédupliqué, vous devrez avoir des variables dans la portée avec des noms comme users[]et deduplicatedUsers[]. Si vous déplacez la déduplication vers une méthode utilitaire, vous pouvez appeler la méthode Utils.dedup(array), et vous pouvez appeler le tableau dédupliqué deduplicatedArrayou simplement result.

  • Les décompilateurs Java utilisent souvent un schéma comme celui pour nommer les variables locales (les variables d'instance et de classe sont normalement disponibles dans le bytecode, mais les variables locales ne le sont pas), et les résultats sont plus lisibles que vous ne le pensez, en fait souvent plus lisibles que le source primaire.

  • Voir le principe de Larry Wall «L'ambiguïté locale est OK» - http://www.wall.org/~larry/natural.html .

user8599
la source
2

Je dirais que vous avez probablement une utilisation spécifique à l'esprit chaque fois que vous créez un objet. Le type seul reflète très rarement cette utilisation.

Donc, si vous souhaitez créer un nouveau contact dans votre application de carnet d'adresses, vous pouvez appeler la variable newContact .

Et si vous effectuez un test unitaire de votre code pour vérifier le comportement des Personobjets sans nom défini, vous pouvez les appelerunnamedPerson ou quelque chose de similaire.

L'appeler personrenonce simplement à une grande chance de rendre votre code auto-documenté.

Joachim Sauer
la source
Appelez ça anonyme! :)) var anonymous = new Person (); Ou mieux encore: var you_know_who = new Person (); :))
Vadim Ferderer
@Vadim Ferderer: var he_who_must_not_be_named = new Person();? :-)
Platinum Azure
2

Seulement si vous programmez en VB6. Dans ce cas , ce que vous faites est illégal, mais pas immoral.

Brianegge
la source
1

Je le fais aussi, et je ne comprends pas non plus pourquoi cela devrait être «immoral». Bien que je puisse comprendre que cela `` puisse '' parfois être déroutant, mais aujourd'hui, nous avons des IDE avec Intellisense et la coloration syntaxique qui garantira que (si vous faites une erreur et référencez votre variable au lieu de votre classe, et vice versa) vous voyez votre erreur assez rapidement. Et nous avons également le compilateur. :)

Frederik Gheysels
la source
1

Je ne vois pas non plus de problème avec cette pratique. Tant qu'il n'y a qu'une seule variable de cette classe, elle est facile à écrire et à lire. Imo, cela s'applique même dans un éditeur de texte de base. Personnellement, je ne me souviens pas que quelqu'un ait qualifié cela de mauvais ou même d'immoral. Continuez simplement à faire ceci :)

mafu
la source
1

Je pense que la «règle» à laquelle vous pensez peut-être est plus destinée aux types primitifs et aux classes où le nom de classe fait un mauvais nom de variable.

Par exemple, si vous deviez calculer le coût d'un article particulier dans une boutique en ligne, le code suivant ne serait pas de bonne forme:

Decimal _decimal = item.BaseCost + item.Tax;

Au lieu de cela, un nom plus descriptif serait conseillé, tel que «_total» ou «_cost».

Jay S
la source
1

Le seul problème avec ce genre de chose que j'ai trouvé est si vous voulez le même nom pour un membre privé et aussi une propriété publique.

Si ceux-ci ne diffèrent que par casse, cela fonctionnera bien dans les langages sensibles à la casse tels que C #, mais pas dans VB.NET.

Donc, par exemple, en VB, j'écrirais

Private _name As String

mais

Public Property Name() As String
    Get
        Return _name
    End Get
    Set(ByVal Value As String)
        _name = Value
    End Set
End Property

Je ferais la même chose en C #, pour que la traduction de l'un à l'autre soit indolore. Cela le rend également un peu moins sujet aux erreurs, car il est très facile de mal lire ou même de taper des mots qui ne diffèrent que par cas.

ChrisA
la source
La seule chose que je n'aime pas dans cette approche est que les variables précédées d'un seul trait de soulignement ont tendance à être associées à des membres privés d'une classe. Mais je suppose que l'approche générale est décente.
Jason Baker
Oui, c'est ce que j'illustre ici. Définir une variable locale, telle que «Dim person as New Person» serait très bien. Très (très) occasionnellement avec le compilateur VB, il y a une ambiguïté, et l'auto-capitalisation rassurante normale ne se produit pas. C'est un bon signal visuel que tout ne va pas bien.
ChrisA
1

Pas immoral, mais si votre meilleur nom pour votre variable est le nom du type, quelque chose ne va pas ou vous faites simplement une preuve de concept ou quelque chose comme ça. Pour moi, un nom de variable doit faire référence à la signification dans le contexte commercial et non au langage de programmation. Il sera plus difficile de comprendre le code.

João Cintra
la source
1

J'utilise souvent Person person = new Person() moi-même. Couramment utilisé en Java / C #.

Même si j'ai fini par me demander hier pourquoi

private enum DataType {NEW, OLD}

ne fonctionne pas en C # ...

Surtout voir comment vous pouvez utiliser String, string, Double, double, ... à volonté en C #.

Carra
la source
enum ne prend en charge que byte, sbyte, short, ushort, int, uint, long, ulong. ie types de valeurs numériques non fractionnaires
Kev
1
Person person = new Person()

est bien dans mon livre.

Quand cela devient horrible, c'est quand vous avez:

string Person;
string person;

Très facile à mélanger les 2.

Johnno Nolan
la source
1

Ce qui m'a été dit, à part le fait de ne pas respecter nos normes de codage, c'est d'éviter d'ajouter de la confusion lorsque quelqu'un d'autre lit mon code. Personnellement, je n'y vois aucun problème, tant que le sens est clair.

En ce qui concerne les types CLR (int, string, etc.), vous pouvez utiliser String ou string (etc.) pour déclarer le type, donc j'éviterais d'utiliser quelque chose comme

int Int = 0;
string String = "hi there";
Muad'Dib
la source
1

Faire de la capitalisation la seule différence est dangereux ... continuez à faire cela pour un gros projet et je vous garantis vous que vous rencontrerez des erreurs bizarres que vous ne parvenez pas à localiser.

fastPerson / slowPerson comme ci-dessus sont très bien ... ils sont descriptifs et différenciés du nom du type de variable ... mais allez man, appeler un int "Int" serait tout simplement paresseux.

Alexwood
la source
1

Je dirais que ce n'est jamais immoral - c'est vraiment juste votre nom de variable de base. Si vous ne pouvez pas penser à un meilleur nom, le nommer après son type est une bonne valeur par défaut. (Pour les types complexes uniquement - pour les types intégrés, c'est mal ) t savoir autre chose sur la variable. Comme avec cette méthode

void SaveToDatabase(Person person) {...}

La seule chose que vous pourriez raisonnablement appeler une personne est person_to_saveou quelque chose comme ça qui semble redondant.

Cependant, dans de nombreux cas, vous pouvez améliorer la lisibilité de votre code en remplaçant la personne par un nom plus descriptif. Par exemple, c'est moins descriptif

void AddToAccount(Account account, Person person)  {...}

que ça

void AddToAccount(Account account, Person dependent)  {...}

Cependant s'il vous plaît, s'il vous plaît - joli s'il vous plaît ne mettez pas un 'a' ou 't' devant le nom du type. IE aPerson pour «une personne» ou tPerson pour «la personne». C'est trop compliqué et n'ajoute pas beaucoup de valeur, voire aucune. De plus, vous commencez à polluer votre portée avec un tas de variables qui commencent par a ou t, ce qui peut minimiser la valeur d'intelli-sense.

Joshua
la source
Je suis d'accord avec le dernier paragraphe. Je ne vois aucune raison d'ajouter des caractères superflus juste pour éviter un problème de style mineur.
Jason Baker le
0

Je ne dirais pas que c'est horrible. Je préfixe généralement le nom de la variable avec `` a '' dans ce genre de chose pour montrer qu'il s'agit d'une seule instance du type, donc je ferais

Person aPerson = new Person();

Cela rend le code plus naturel, je pense.

Rob K
la source
0

Absolument rien de mal à cela, sous réserve des mises en garde soulignées par d'autres (résumant ici pour plus de commodité): ne pas le faire avec des types primitifs, refactoriser l'instance d'origine si une autre instance est ajoutée plus tard, ne pas utiliser char-case pour différencier les noms de classe, etc.

Ma règle d'or? Les instructions dans le code doivent se lire comme de simples phrases anglaises.

Personne personne = nouvelle personne ();

Employé employé = person.getRole (EMPLOYEE);

Parent parent = person.getRole (PARENT);

person.getFullName ();

employee.getSalary ();

parent.getChildren ();

parent.getFullName (); // en assumant le motif du décorateur en jeu

if (person.hasRole (EMPLOYEE)) {

  ...

}

Et ainsi de suite.

Si la portée de la variable est limitée (la méthode d'encapsulation est de 10 à 15 lignes, par exemple), je pourrais même utiliser «p» au lieu de «personne». Les noms de variables plus courts sont moins une distraction lorsque vous essayez de garder le contexte dans votre tête. Évitez les préfixes gratuits tels que «a» ou (frisson) la notation hongroise et ses dérivés. (Remarquez que je n'ai rien contre de tels préfixes lorsqu'ils sont utilisés dans le contexte approprié - code API C ++ / COM / ATL / Win32, etc., où cela aide à garder les affectations / la typographie droite).

Mes deux (!) Bits :-)

alan-p
la source