Quelle est la terminologie appropriée en anglais pour faire référence à l'objet en C++?

Question

Quelle est la terminologie correcte/appropriée en anglais pour faire référence à l'objet "courant" en C++. Par exemple, supposons que vous écrivez un commentaire dans le corps de la mise en œuvre de celle-ci:

Thing Thing::operator+(const Thing& other) 

Vous avez le nom de la variable « autre » à utiliser pour l'autre objet, mais ce mot/expression que vous utilisez pour faire référence à l'objet qui fait l'opération?

Answer 1

Tout d'abord, il y a le pointeur this spécifiquement à cet effet. Il est donc naturel de se référer à l'objet courant comme "cet objet".

Answer 2

En C++ c'est l'objet this et c'est ce que j'utilise.

Modifier: Je deuxième commentaire de Neil à propos operator+() mieux d'être un non-membre. Pour moi, la forme canonique est de mettre en œuvre += en tant que membre (il change l'objet côté gauche et doit donc avoir accès) et mettre en œuvre operator+ sur elle:

inline Thing operator+(Thing lhs, const Thing& rhs) 
{ 
    lhs += rhs; 
    return lhs; 
} 

(Note: je pour passer lhs par référence const, aussi, et effectuer la copie dans la fonction, mais a été convaincu il ya un certain temps qu'il vaut mieux le passer comme une copie à la place.)

Answer 3

Pourrait également utiliser "opérande gauche" et "opérande de droite ", puisque votre opérateur est binaire.

Answer 4

Il n'y a pas objet courant en C++, mais seulement pointeur vers objectera avalilable dans la fonction membre est ce pointeur.

Answer 5

Le problème avec « ce » est qu'il est un mot commun en anglais. En tant que quelqu'un qui a beaucoup parlé du C++, j'ai toujours eu du mal à comprendre quand j'utilisais "ceci" pour désigner l'objet courant. Je n'ai jamais trouvé une solution parfaite, mais j'ai souvent souhaité que BS ait utilisé "self" au lieu de "this".

Answer 6

Soit "ce", ou peut-être "cette instance". Comme dans:

/** \brief Adds another Thing to this instance. 
* A reference to this instance is returned. 
*/ 
Thing& Thing::operator+(const Thing& other); 

Le balisage est Doxygen, pour ceux qui ne connaissent pas cela.

Answer 7

J'ai tendance à utiliser la même convention dans la documentation que je l'utilise dans le code: Je laisse implicite. Par exemple. "Ajouter une autre chose et retourner la somme".

Quand je besoin d'être explicite, il est des commentaires lus par d'autres programmeurs. Ils connaissent C++, *this est facilement compris. Par exemple. "Ajouter une autre chose à en ajoutant tous les membres sauf Thing :: foo qui deviendra 0 (Voir bug # 42)"

Answer 8

Dans les commentaires, je dis habituellement soit "ceci" ou "nous-même" (parce que j'écris généralement des commentaires à la première personne du pluriel, mais "nous-mêmes" est trop bizarre quand il n'y a qu'un seul objet).

Dans la documentation, je dis "le <whatever>". Si c'est ambigu (parce que la fonction en prend une autre en paramètre, par exemple), je dis "cet objet", ou "ceci <whatever>".<whatever> est soit le nom de la classe, soit un autre terme utilisé dans la documentation pour expliquer ce que la classe représente.

/** 
* An utterly useless write-only counter, with arbitrary initial value. 
*/ 
class Counter { 
    unsigned int count; 
public: 
    /** 
    * Increments the counter 
    */ 
    Counter &operator++() { 
     // We need to add 1 to ourself. I found a snippet online that does it: 
     ++count; 
     // return ourself 
     return *this; 
    } 
    /** 
    * Adds together this counter and "other". 
    */ 
    Counter operator+(const Counter &other) const { 
     Counter result; 
     // new count is our count plus other count 
     result.count = count + other.count; 
     return result; 
    } 
}; 

Answer 9

Si vous implémentez un opérateur en dehors du champ de la classe, alors les arguments sont souvent nommés lhs et rhs (côté gauche et côté droit).

Vous n'avez pas vraiment besoin d'un nom pour l'objet actuel, car vous avez déjà le pointeur this. Dans les méthodes statiques, un pointeur est parfois nécessaire pour un objet de la classe (par exemple pour appeler une méthode d'instance). Dans ces situations, j'utilise le nom de la variable pThis.

Si vous avez besoin d'un nom lorsque vous en parlez, alors "self" a du sens. Je me réfère parfois à "l'objet".

Answer 10

Il me semble que si vous voulez faire référence à l'objet actuel, vous ne pouvez pas vraiment vous tromper en l'appelant l'objet actuel.