Ce que signifie le modificateur const après une déclaration de méthode - page 6

Nouveau commentaire
 
Méthodes constantes
Les méthodes constantes se distinguent par le fait qu'elles ne modifient pas les valeurs des champs de leur classe. Examinons un exemple appelé CONSTFU :
// constfu.cpp
// применение константных методов
class aClass
{
private:
    int alpha;
public:
    void nonFunc()    // неконстантный метод
    { 
        alpha = 99;
    }      // корректно
    void conFunc()const   // константный метод
    { 
        alpha = 99;
    }    // ошибка: нельзя изменить значение поля
};

Une méthode normale nonFunc() peut modifier la valeur du champ alpha, mais pas une méthode constante conFunc(). Si une tentative est faite pour modifier le champ alpha, le compilateur signalera une erreur.
Pour faire d'une fonction une constante, le mot clé const doit être spécifié après le prototype de la fonction, mais avant le début du corps de la fonction. Si la déclaration et la définition de la fonction sont séparées, le modificateur const doit être spécifié deux fois - à la fois dans la déclaration de la fonction et dans sa définition. Il est logique de rendre ces méthodes, qui ne lisent que les données du champ de la classe, constantes, car elles n'ont pas besoin de modifier les valeurs des champs de l'objet de la classe.

L'utilisation de fonctions constantes aide le compilateur à détecter les erreurs et indique également au lecteur du listing que la fonction ne modifie pas les valeurs des champs de l'objet. Les fonctions constantes peuvent être utilisées pour créer et utiliser des objets constants, comme nous le verrons plus tard.

Un exemple de la classe Distance

Afin de ne pas inclure de nombreuses innovations dans un seul programme, nous n'avons jusqu'à présent pas utilisé de méthodes constantes dans nos exemples. Cependant, il existe un certain nombre de situations où l'utilisation de méthodes constantes serait utile. Par exemple, la méthode showdist() de la classe Distance, qui apparaît à plusieurs reprises dans nos exemples, aurait dû être rendue constante car elle ne modifie pas (et ne devrait pas !) les champs de l'objet pour lequel elle est appelée. Il est uniquement destiné à afficher les valeurs actuelles des champs à l'écran.

...

extrait de la p. 250, Lafauré R. - Object-Oriented Programming in C++ (4th ed.) 2004

 
Dmitry Fedoseev:

C'est ce que l'on veut dire, car dans ce contexte, on ne parle pas de type. Une "classe propre" est évidemment sa propre instance (c'est-à-dire un objet).

Le membre_x appartient à la même classe que la méthode bar.

C obj._x - ici le membre _x est dans une classe étrangère obj.

Il me semble acceptable de parler d'une classe plutôt que d'une instance, car il est évident que _x appartient à notre classe, que nous écrivons, et obj.x à la classe étrangère, que nous gérons.

En parlant de terminologie OOP, toute la terminologie ici est un peu de cela (ou même beaucoup).

Dmitry, comprenez-vous que si vous parlez de cette façon, ceux qui commenceront à se familiariser avec la POO avec une telle terminologie pour la première fois deviendront fous !

C'est ce que vous voulez dire, car nous ne parlons pas d'un type dans ce contexte. "Sa classe" est évidemment sa propre instance (c'est-à-dire son objet).

C'est probablement évident pour vous. Je lis et me demande comment un membre _x peut appartenir à une classe si la classe est une instruction, une abstraction, comme vous l'avez dit vous-même :

Forum sur le trading, les systèmes de trading automatisés et les tests de stratégie

Que signifie le modificateur const après une déclaration de méthode ?

Dmitry Fedoseev, 2016.02.01 19:06

Comment un objet peut-il appeler une méthode ? Une méthode peut être appelée depuis une fonction ou depuis une autre méthode.

Ce n'est pas seulement une méthode de classe qui est appelée, mais une méthode d'un objet spécifique. La classe elle-même est une abstraction.

C obj._x - ici le membre _x se trouve dans une classe étrangère obj.

Vous ne comprenez vraiment pas la différence entre une classe et une instance de classe ? Vous ne pouvez pas dire cela, en aucun cas, car cela fera exploser le cerveau du lecteur, qui pensera que l'objet qui a appelé la méthode et l'objet obj sont des instances de classes différentes, alors qu'ils sont des instances d'une seule classe (dans l'exemple que vous avez cité).

En parlant de terminologie OOP, toute la terminologie ici est un peu de cela (ou même beaucoup).

La terminologie est un "petit truc" quand on ne comprend pas de quoi il s'agit. Il suffit de bien comprendre ce qu'est une classe (instruction) et ce qu'est un objet (instance) d'une classe. Et alors beaucoup de problèmes disparaîtront d'eux-mêmes. De toute évidence, je ne pourrai pas vous faire changer d'avis, et je ne vois donc pas l'intérêt de poursuivre la discussion sur ce sujet. C'est dommage.
 
unreal:
Méthodes constantes
Les méthodes constantes se distinguent par le fait qu'elles ne modifient pas les valeurs des champs de leur classe. Examinons un exemple appelé CONSTFU :
// constfu.cpp
// применение константных методов
class aClass
{
private:
    int alpha;
public:
    void nonFunc()    // неконстантный метод
    { 
        alpha = 99;
    }      // корректно
    void conFunc()const   // константный метод
    { 
        alpha = 99;
    }    // ошибка: нельзя изменить значение поля
};

Une méthode normale nonFunc() peut modifier la valeur du champ alpha, mais pas une méthode constante conFunc(). Si une tentative est faite pour modifier le champ alpha, le compilateur signalera une erreur.
Pour faire d'une fonction une constante, le mot clé const doit être spécifié après le prototype de la fonction, mais avant le début du corps de la fonction. Si la déclaration et la définition de la fonction sont séparées, le modificateur const doit être spécifié deux fois - à la fois dans la déclaration de la fonction et dans sa définition. Il est logique de rendre ces méthodes, qui ne lisent que les données du champ de la classe, constantes, car elles n'ont pas besoin de modifier les valeurs des champs de l'objet de la classe.

L'utilisation de fonctions constantes aide le compilateur à détecter les erreurs et indique également au lecteur du listing que la fonction ne modifie pas les valeurs des champs de l'objet. Les fonctions constantes peuvent être utilisées pour créer et utiliser des objets constants, comme nous le verrons plus tard.

Un exemple de la classe Distance

Afin de ne pas inclure de nombreuses innovations dans un seul programme, nous n'avons jusqu'à présent pas utilisé de méthodes constantes dans nos exemples. Cependant, il existe un certain nombre de situations où l'utilisation de méthodes constantes serait utile. Par exemple, la méthode showdist() de la classe Distance, qui apparaît à plusieurs reprises dans nos exemples, aurait dû être rendue constante car elle ne modifie pas (et ne devrait pas !) les champs de l'objet pour lequel elle est appelée. Il est uniquement destiné à afficher les valeurs actuelles des champs à l'écran.

...

extrait de la p. 250, Lafauré R. - Object-Oriented Programming in C++ (4th ed.) 2004

Mais quel ordre sera dans votre esprit si même dans un livre sur la POO ils écrivent soit juste soit faux. Bien que, peut-être, c'est la traduction.
 
Alexey Kozitsyn:

Dmitry, comprenez-vous que si vous parlez ainsi, ceux qui commencent à se familiariser avec la POO avec une telle terminologie pour la première fois vont devenir fous ?

C'est probablement évident pour vous. Je suis en train de lire et de penser comment un membre _x peut appartenir à une classe, si une classe est une instruction, une abstraction, comme vous l'avez dit vous-même :

Vous ne comprenez vraiment pas la différence entre une classe et une instance de classe ? Vous ne pouvez pas dire cela, en aucun cas, car cela provoquera une explosion de cerveau chez le lecteur et il pensera que l'objet qui a appelé la méthode et l'objet obj sont des instances de classes différentes, alors que ce sont des instances de la même classe (dans l'exemple que vous avez donné).

La terminologie est alors "un peu de ça" quand on ne comprend pas ce à quoi on a affaire. Il suffit de comprendre clairement ce qu'est une classe (instruction) et ce qu'est un objet (instance) d'une classe. Et alors beaucoup de problèmes disparaîtront d'eux-mêmes. De toute évidence, je ne pourrai pas vous faire changer d'avis, et je ne vois donc pas l'intérêt de poursuivre la discussion sur ce sujet. C'est dommage.

Pourquoi devrais-tu me faire changer d'avis ? Changer d'avis sur quoi ? Tout va bien pour moi. Le premier message de ce fil de discussion m'a suffi pour avoir une compréhension complète sans conflit.

Notez également que c'est vous qui avez écrit que la référence serait suffisante pour comprendre. Donc, le sujet de votre discussion n'est pas clair du tout ?

ps. Ne m'attribue pas un tas de tes propres illusions.

 
George Merts:

Personnellement, j'ai toujours compris les méthodes constantes comme des méthodes qui ne peuvent pas modifier les variables de classe.

Je les ai très rarement utilisés, car j'ai souvent rencontré une situation où la redéfinition d'une méthode nécessite de changer quelque chose, alors que la méthode de base est constante (cela a déjà été mentionné ici).

Les méthodes statiques sont largement utilisées. Dans presque toutes les classes complexes. Il s'agit généralement de méthodes supplémentaires "de service" qui ne nécessitent pas d'accès aux variables de la classe.

De plus, pour les constantes comme "nombre de secondes dans un jour", j'essaie d'utiliser un const statique, plutôt que #define. Dans ce cas, la déclaration et l'initialisation d'une telle constante se trouvent à des endroits différents, mais le contrôle de type a lieu et il m'a dépanné plus d'une fois.

La même chose que j'utilise rarement. En fait, j'ai lancé ce sujet parce que l'un des participants de ce forum m'a demandé dans un message privé pourquoi j'en avais besoin.
 
George Merts:

Personnellement, j'ai toujours compris les méthodes constantes comme des méthodes qui ne peuvent pas modifier les variables de classe.

Je ne les utilise que très rarement, car il m'est arrivé plus d'une fois de me retrouver dans une situation où une surcharge de méthode doit changer quelque chose, alors que la méthode de base est constante (cela a déjà été mentionné ici).

Vous ne les utilisez PAS pour cette raison, et je les utilise pour cette raison :

zaskok3:

Pour moi, l'utilisation de const et static augmente considérablement la lisibilité/compréhension de mon propre code. Et vous permet souvent de détecter les bogues ou les défauts de votre propre architecture dès le début de sa mise en œuvre.


Je n'écris tout que pour moi. Et il semblerait que je ne changerai pas certaines données que je ne devrais pas de toute façon. Mais le désir de me protéger de ma propre stupidité me fait riveter l'architecture OOP d'une telle manière, que seul ce qui doit être accessible à changer. Le reste ne l'est pas. Et c'est là que les types const + inheritance sont d'une grande aide. Je le recommande.
 

Merci de m'aider à compiler EA, je ne suis pas doué pour la programmation.

Voici l'erreur que j'obtiens en compilant 'delete' - nom attendu

L'erreur dans le code est mise en évidence en rouge

void delete(int type){

si(OrdersTotal()>0){

for(i=OrdersTotal()-1;i>=0;i--){

OrderSelect(i,SELECT_BY_POS,MODE_TRADES) ;

if(type!=6 && type!=7 && type!=8)if(OrderSymbol()==Symbol() && OrderMagicNumber()==magique && OrderType()==type)OrderDelete(OrderTicket() ;

if(type==6)if(OrderSymbol()==Symbol() && OrderMagicNumber()==magic && OrderType()==OP_BUYSTOP || OrderType()==OP_SELLSTOP || OrderType()==OP_BUYLIMIT || OrderType()==OP_SELLLIMIT)OrderDelete(OrderTicket()) ;

if(type==7)if(OrderSymbol()==Symbol() && OrderMagicNumber()==magic && OrderType()==OP_BUYSTOP || OrderType()==OP_BUYLIMIT)OrderDelete(OrderTicket()) ;

if(type==8)if(OrderSymbol()==Symbol() && OrderMagicNumber()==magic && OrderType()==OP_SELLSTOP || OrderType()==OP_SELLLIMIT)OrderDelete(OrderTicket()) ;

}

}

}


Voici une autre erreur '(' - pointeur d'objet attendu

if(oppositedelete){delete(OP_SELLSTOP);delete(OP_SELLLIMIT);}

Et ici "} - tous les chemins de contrôle ne renvoient pas une valeur

int countglobal(){

int cnt=0 ;

si(OrdersTotal()>0){

for(i=OrdersTotal()-1;i>=0;i--){

OrderSelect(i,SELECT_BY_POS,MODE_TRADES) ;

cnt++ ;

}

retour(cnt) ;

}

}

 
zaskok3:

Vous ne les utilisez PAS pour cette raison, et je les utilise pour cette raison :

Je suis d'accord que le spécificateur const est utile pour lire et comprendre des fonctions écrites en long et en large. Mais restreindre l'accès aux variables me semble plus logique en les déclarant dans différentes sections privées-protégées-publiques (personnellement, je ne déclare jamais les variables comme publiques, seulement les méthodes).

Il m'est difficile de penser à une situation où une variable interne de classe ne devrait pas être modifiée dans les descendants.

 
Anton Razmyslov:

Les personnes aimables aident avec la compilation d'EA très s'il vous plaît, pas bon à la programmation.

Et dans la logique ? Pourquoi encombrer un sujet sans intérêt avec des questions comme celle-ci ?
 

D'ailleurs, personne n'a écrit que le modificateur Const ne permet pas seulement de changer les données à l'intérieur de sa propre classe, mais même d'adresser des méthodes non constantes. Un exemple simple : il existe une classe de positions, nous devons trier la liste des positions par profit. Le bénéfice est calculé par la demande :

class CPosition : public CObject
{
private:
   double m_profit;
   void CalculateProfit()
   {
      m_profit = 31337;
   }
public:
   CPosition(void) : m_profit(0.0)
   {
   }
   double Profit(void)const
   {
      if(m_profit == 0.0)
         CalculateProfit(); // <- Константный метод вызывает блок рассчета и вызывает ошибку
      return m_profit;
   }
   virtual int Compare(const CObject *node,const int mode=0) const
   {
      const CPosition* pos = node;
      if(pos.Profit() > Profit())
         return 1;
      else if(pos.Profit() < Profit())
         return -1;
      return 0;
   }
};

Ce code provoquera une erreur car, bien que la méthode Profit soit constante, elle fait référence à la méthode non constante CalcultaeProfit si le bénéfice n'a pas encore été calculé.

Notez que la méthode Profit elle-même est absolument sûre : elle garantit que la valeur qu'elle renvoie n'est pas vide. Toutefois, la méthode constante exige d'abandonner les calculs en coulisse et la sécurité du code au profit de constructions prêtes à l'emploi qui ne savent pas ce qu'elles limitent et pourquoi elles le font.

1234567
Nouveau commentaire
Raison: