Conventions pour les méthodes accesseurs (getters et setters) en C++

De mon point de vue que de s'asseoir avec 4 millions de lignes de code C++ (et ce n'est qu'un projet) à partir d'un entretien de point de vue, je dirais:

• C'est ok de ne pas utiliser des getters/setters si les membres sont immuables (c'est à dire const) ou de simples sans dépendances (comme une classe point avec les membres X et Y).

• Si un membre du private que c'est aussi ok pour ignorer des getters/setters. Je compte également des membres de l'interne pimpl-classes comme private si l' .rpc unité est petite.

• Si un membre du public ou protected (protected est tout aussi mauvais que public) et nonconst, non simple ou a des dépendances ensuite utiliser des getters/setters.

Comme un gars de l'entretien, ma principale raison de vouloir avoir des getters/setters est parce que j'ai alors un endroit pour mettre des points d'arrêt /enregistrement /quelque chose d'autre.

Je préfère le style de la variante 2. comme c'est plus consultable (un élément clé dans l'écriture de code maintenable).

2) est le meilleur de l'OMI, car il rend vos intentions les plus claires. set_amount(10) est plus significative que amount(10), et comme un effet secondaire de nice, permet à un membre nommé amount.

Variables publiques est généralement une mauvaise idée, car il n'y a pas d'encapsulation. Supposons que vous avez besoin de mettre à jour un cache ou d'actualisation d'une fenêtre lorsqu'une variable est mise à jour? Tant pis si vos variables sont publiques. Si vous avez une méthode de jeu, vous pouvez l'ajouter là.

En général, j'ai l'impression que ce n'est pas une bonne idée d'avoir trop de getters et setters être utilisé par un trop grand nombre d'entités dans le système. C'est juste une indication d'une mauvaise conception ou de mauvaise encapsulation.

Après avoir dit que, si une telle conception doit être refait, et le code source est disponible, je préfère utiliser le Design pattern Visiteur. La raison en est:

un. Il donne une classe l'occasion de
décider qui à permettre l'accès à ses
privé de l'état

b. Il donne une classe un
la possibilité de décider ce que l'accès à
permettre à chacune des entités qui sont
intéressé dans son privé de l'état

c. Il
clairement des documents tels exteral accès
par le biais d'un interface de classe de

Idée de base est:

a) la Refonte si possible d'autre,

b)
Refactoriser tels que

1. Tous l'accès à l'état de classe est par l'intermédiaire d'un bien connu individualiste
   interface

2. Il devrait être possible de configurer certains sorte de le faire et ne pas faire
   pour chaque interface, par exemple, tous les
   l'accès à partir d'entité externe BONNE
   devraient être autorisés, tous les accès à partir de
   entité externe MAUVAIS devrait être
   interdits et externe de l'entité OK
   devrait être autorisé à obtenir, mais pas ensemble (par exemple)

J'ai vu l'idéalisation des classes plutôt que les types intégraux à consulter des données significatives.

Quelque chose comme ci-dessous n'est généralement pas une bonne utilisation de C++ propriétés:

struct particle {
    float mass;
    float acceleration;
    float velocity;
} p;

Pourquoi? Parce que le résultat de p.la masse*p.l'accélération est un float et non pas de la force comme prévu.

La définition de classes de désigner un but (même si c'est une valeur, comme montant mentionné précédemment), plus de sens, et de nous permettre de faire quelque chose comme:

struct amount
{
    int value;

    amount() : value( 0 ) {}
    amount( int value0 ) : value( value0 ) {}
    operator int()& { return value; }
    operator int()const& { return value; }
    amount& operator = ( int const newvalue )
    {
        value = newvalue;
        return *this;
    }
};

Vous pouvez accéder à la valeur du montant implicitement par l'opérateur int. En outre:

struct wage
{
    amount balance;

    operator amount()& { return balance; }
    operator amount()const& { return balance; }
    wage& operator = ( amount const&  newbalance )
    {
        balance = newbalance;
        return *this;
    }
};

Getter/Setter utilisation:

void wage_test()
{
    wage worker;
    (amount&)worker = 100; //if you like this, can remove = operator
    worker = amount(105);  //an alternative if the first one is too weird
    int value = (amount)worker; //getting amount is more clear
}

C'est une approche différente, ne signifie pas qu'il est bon ou mauvais, mais différent.

Une autre possibilité pourrait être :

int& amount();

Je ne suis pas sûr, je le recommande, mais il a l'avantage de l'insolite notation peut s'abstenir aux utilisateurs de modifier les données.

str.length() = 5; //Ok string is a very bad example :)

Parfois, il est peut-être juste le bon choix à faire:

image(point) = 255;  

Une autre possibilité encore une fois, utiliser la notation fonctionnelle pour modifier l'objet.

edit::change_amount(obj, val)

De cette façon dangereuse/fonction d'édition peut être retiré dans un namespace avec sa propre documentation. Celui-ci semble venir naturellement à la programmation générique.