Parlare dell'OLP nel salone - pagina 15

[Alexey Volchanskiy]

Vladimir Pastushak:

Dove sta andando tutta la strada?

Controlla la tua posta.

[TheXpert]

Ciao, moderatori! Ho fatto una domanda normale alla quale ho ricevuto maleducazione. Se lo demolite, demolite anche gli operatori e i puntatori senza senso.

E che Sokolov non appaia affatto nei topic OOP, con tali sostenitori dell'OOP sul forum morirà in agonia.

[Artyom Trishkin]

Комбинатор:

Ciao, moderatori! Ho fatto una domanda normale, alla quale ho ricevuto maleducazione, quindi se la demolite, demolite anche le sciocchezze sugli operatori e la segnaletica.

E non lasciate che Sokolov appaia nei topic di OOP, con tali sostenitori di OOP il forum morirà in agonia.

Ha chiarito qualcosa sul suo punto di vista? No.

Ho cancellato un semplice battibecco.

[fxsaber]

Un buon esempio sul tema dell'OOP.

[TheXpert]

Artyom Trishkin:
Ha chiarito qualcosa sul suo punto di vista? No.

Cosa avrei dovuto chiarire con una domanda di due parole?

[Denis Kirichenko]

Vasiliy Sokolov:

Sovrascrivere gli operatori non dà altro che zucchero sintattico. È meglio abbandonare questa pratica e usare il metodo Copy() o Clone() invece dell'operatore di assegnazione - semplice e chiaro:

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

Vasily, grazie per la tua opinione. Sono d'accordo con il tuo approccio con una piccola aggiunta:

//+------------------------------------------------------------------+
//| Тестовый класс                                                   |
//+------------------------------------------------------------------+
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;
     }
  };

Controllo dello 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());
  }

I caratteri di confronto standard sono meglio lasciati dietro i puntatori.

Cosa intendete per puntatori? In questo senso?

CMyClass* ptr1,ptr2;
ptr2=ptr1;

[TheXpert]

Oh, mio Dio...

[Artyom Trishkin]

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

E poi?

Di solito c'è una giustificazione e un'opzione.

[Vasiliy Sokolov]

Artyom Trishkin:
Ha spiegato qualcosa sul suo punto di vista? No.

Ho cancellato un semplice battibecco.

Non cederò alle provocazioni degli haters, che sono anche analfabeti, ma spiegherò piuttosto il mio punto di vista:

Nei normali linguaggi di programmazione(non C++), ilsovraccarico dell'operatore '=' è vietato. E in alcuni, il sovraccarico dell'operatore è proibito quasi completamente, dato che lì è meritatamente considerato un anti-pattern. Suggerisco che prima di usare un tale sovraccarico, specialmente l'operatore di assegnazione, quelli che lo desiderano, pensino bene al perché quegli stupidi architetti di quelle stupide lingue lo fanno.

Non ho potuto resistere, personalmente ad andrei: cavolo, non metterti in imbarazzo così. State dicendo cose così sciocche: prima su FP, ora sugli operatori. Vuoi hayterite - benvenuto: dare riferimenti a fonti autorevoli, giustificare, ecc. Quello che state facendo ora è un odio rabbioso e soprattutto totalmente analfabeta. Lei sembra essere un programmatore, come anche uno vero - è già vergognoso scrivere cose del genere.

[Koldun Zloy]

Dennis Kirichenko:

Artem, ti sbagli. Cosa si può fare senza le ragazze? - Le ragazze sono tutte nostre :-))

Ma seriamente, ecco cosa voglio discutere. C'è una classe in cui è scritto il costruttore di copia e l'operatore di assegnazione è sovrascritto. Domanda. Quando dovrebbero essere e devono essere diversi?

Il compilatore stesso crea un semplice costruttore di copia che copia semplicemente tutti i membri della classe o della struttura.

Se volete che vengano eseguite altre azioni durante la copia, potete definire il vostro costruttore di copia

e operatore di assegnazione.

L'operatore di assegnazione è chiamato per un oggetto esistente, quindi deve prima controllare se l'assegnazione

stesso, poi rilasciare l'oggetto esistente se necessario, e poi fare la stessa cosa del costruttore.