Parler de l'OLP dans le salon - page 15

[Alexey Volchanskiy]

Vladimir Pastushak:

Où va-t-il jusqu'au bout ?

Vérifiez votre courrier.

[TheXpert]

Bonjour, modérateurs ! J'ai posé une question normale à laquelle j'ai eu droit à des grossièretés. Si vous le démolissez, démolissez aussi les opérateurs et les inepties des pointeurs.

Et ne laissez pas du tout Sokolov apparaître dans les sujets OOP, avec de tels défenseurs d'OOP sur le forum, il mourra dans l'agonie.

[Artyom Trishkin]

Комбинатор:

Bonjour, modérateurs ! J'ai posé une question normale, à laquelle j'ai reçu des grossièretés, alors si vous la démolissez, démolissez aussi les absurdités concernant les opérateurs et les panneaux indicateurs.

Et ne laissez pas du tout Sokolov apparaître dans les sujets OOP, avec de tels défenseurs de l'OOP, le forum mourra dans l'agonie.

Avez-vous clarifié quelque chose sur votre point de vue ? Non.

J'ai supprimé une simple querelle.

[fxsaber]

Un bon exemple sur le sujet de la POO.

[TheXpert]

Artyom Trishkin:
Avez-vous clarifié quelque chose sur votre point de vue ? Non.

Qu'est-ce que j'étais censé clarifier avec une question de deux mots ?

[Denis Kirichenko]

Vasiliy Sokolov:

Le remplacement des opérateurs ne donne rien d'autre que du sucre syntaxique. Il est préférable d'abandonner cette pratique et d'utiliser la méthode Copy() ou Clone() au lieu de l'opérateur d'affectation - simple et clair :

class CMyClass
{
private:
   int m_state;
public:
   CMyClass* Copy()
   {
      CMyClass* obj = new CMyClass();
      obj.m_state = state;
      return obj;
   }
}

Vasily, merci pour votre opinion. Je suis d'accord avec votre approche avec un petit ajout :

//+------------------------------------------------------------------+
//| Тестовый класс                                                   |
//+------------------------------------------------------------------+
class CMyClass
  {
private:
   int               m_state;

public:
   //--- конструктор\деструктор
   void CMyClass(){m_state=WRONG_VALUE;};
   void ~CMyClass(){};
   //--- копирование
   bool Copy(const CMyClass &_src_obj)
     {
      int source_state=_src_obj.m_state;
      if(source_state!=WRONG_VALUE)
        {
         this.m_state=source_state;
         return true;
        }
      return false;
     }
   //--- клонирование
   CMyClass *Clone(void)
     {
      CMyClass *obj=new CMyClass();
      if(CheckPointer(obj)==POINTER_DYNAMIC)
         obj.m_state=this.m_state;
      return obj;
     }
   //--- set\get
   void State(const int _src_state)
     {
      this.m_state=_src_state;
     }
   int State(void) const
     {
      return this.m_state;
     }
  };

Vérification du script :

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- Объект 1
   CMyClass my_obj1;
   my_obj1.State(5);
   PrintFormat("Состояние Объекта 1: %d",my_obj1.State());
//--- Объект 2 - методом клонирования
   CMyClass *ptr_my_obj2;
   ptr_my_obj2=my_obj1.Clone();
   if(CheckPointer(ptr_my_obj2)==POINTER_DYNAMIC)
      PrintFormat("Состояние Объекта 2: %d",ptr_my_obj2.State());
//--- Объект 3 - методом копирования
   CMyClass my_obj3;
   my_obj3.State(3);
   PrintFormat("Состояние Объекта 3: %d",my_obj3.State());
   if(my_obj1.Copy(my_obj3))
      PrintFormat("Состояние Объекта 1: %d",my_obj1.State());
  }

Il est préférable de laisser les caractères de comparaison standard derrière les pointeurs.

Qu'entendez-vous par pointeurs ? Dans ce sens ?

CMyClass* ptr1,ptr2;
ptr2=ptr1;

[TheXpert]

Oh mon Dieu...

[Artyom Trishkin]

Комбинатор:
Oh, mon...

Et puis quoi ?

Il y a généralement une justification et une option.

[Vasiliy Sokolov]

Artyom Trishkin:
Avez-vous expliqué votre point de vue ? Non.

J'ai supprimé une simple querelle.

Je ne céderai pas aux provocations des haineux, qui sont aussi des analphabètes, mais j'expliquerai mon point de vue :

Dans les langages de programmation normaux(pas en C++), lasurcharge de l'opérateur '=' est interdite. Je suggère qu'avant d'utiliser une telle surcharge, en particulier l'opérateur d'affectation, ceux qui le souhaitent réfléchissent sérieusement à la raison pour laquelle les architectes stupides de ces langages stupides font cela.

Je n'ai pas pu résister, personnellement à andrei : bon sang, ne te mets pas dans l'embarras comme ça. Vous dites des choses si stupides : d'abord sur la FP, maintenant sur les opérateurs. Vouloir hayterite - bienvenue : donner des références à des sources faisant autorité, justifier, etc. Ce que vous faites maintenant, c'est une haine enragée et surtout totalement analphabète. Vous semblez être un programmeur, comme même un vrai - c'est déjà honteux d'écrire de telles choses.

[Koldun Zloy]

Dennis Kirichenko:

Artem, tu as tort. Que pouvez-vous faire sans les filles ? - Les filles sont toutes à nous :-))

Mais sérieusement, voici ce dont je veux discuter. Il existe une classe dans laquelle le constructeur de copie est écrit et l'opérateur d'affectation est surchargé. Question. Quand doivent-ils l'être et doivent-ils être différents ?

Le compilateur crée lui-même un constructeur de copie simple qui copie simplement tous les membres de la classe ou de la structure.

Si vous souhaitez que d'autres actions soient exécutées lors de la copie, vous pouvez définir votre propre constructeur de copie

et l'opérateur d'affectation.

L'opérateur d'assignation est appelé pour un objet existant, il doit donc d'abord vérifier si l'assignation

lui-même, puis libère l'objet existant si nécessaire, et ensuite fait la même chose que le constructeur.