Conversando sobre a OLP no salão - página 15

[Alexey Volchanskiy]

Vladimir Pastushak:

Para onde está indo até o fim?

Verifique seu correio.

[TheXpert]

Olá, moderadores! Fiz uma pergunta normal à qual recebi indelicadeza. Se você a demolir, demolir operadores e indicar disparates também.

E não deixe Sokolov aparecer em tópicos do OOP, com tais defensores do OOP no fórum, ele morrerá em agonia.

[Artyom Trishkin]

Комбинатор:

Olá, moderadores! Fiz uma pergunta normal, à qual recebi indelicadeza, portanto, se você a derrubar, derrube também os disparates sobre os operadores e as placas de sinalização.

E não deixe Sokolov aparecer em tópicos do OOP, com tais defensores do OOP, o fórum morrerá em agonia.

Você esclareceu alguma coisa sobre o seu ponto de vista? Não.

Eu apaguei uma simples briga.

[fxsaber]

Um bom exemplo sobre o tema do OOP.

[TheXpert]

Artyom Trishkin:
Você esclareceu alguma coisa sobre o seu ponto de vista? Não.

O que eu deveria esclarecer em uma pergunta de duas palavras?

[Denis Kirichenko]

Vasiliy Sokolov:

Os operadores superiores não dão nada além de açúcar sintático. É melhor abandonar esta prática e usar o método Copy() ou Clone() em vez de operador de atribuição - simples e claro:

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

Vasily, obrigado por sua opinião. Concordo com sua abordagem com uma pequena adição:

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

Roteiro de verificação:

//+------------------------------------------------------------------+
//| 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());
  }

Os caracteres de comparação padrão são melhor deixados para trás do que os ponteiros.

O que você quer dizer com ponteiros? Neste sentido?

CMyClass* ptr1,ptr2;
ptr2=ptr1;

[TheXpert]

Oh, meu Deus...

[Artyom Trishkin]

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

E depois?

Geralmente há uma justificativa e uma opção.

[Vasiliy Sokolov]

Artyom Trishkin:
Você já explicou alguma coisa sobre seu ponto de vista? Não.

Eu apaguei uma simples briga.

Não vou ceder às provocações dos detratores, que também são analfabetos, mas sim explicar meu ponto de vista:

Em linguagens de programação normais(não C++), asobrecarga do operador '=' é proibida. E, em alguns, a sobrecarga do operador é quase completamente proibida, pois ali é merecidamente considerada anti-padrão. Sugiro que antes de usar qualquer sobrecarga, especialmente o operador de tarefas, aqueles que o desejarem, pensem bem no porquê desses estúpidos arquitetos dessas estúpidas linguagens fazem isso.

Não podia resistir, pessoalmente a andrei: cara, não se envergonhe dessa maneira. Você está dizendo coisas tão bobas: primeiro sobre FP, agora sobre operadores. Desejar hayterite - bem-vindo: dar referências a fontes confiáveis, justificar, etc. O que você está fazendo agora é um ódio raivoso e, o mais importante, totalmente analfabeto. Você parece ser um programador, como até mesmo um programador real - já é vergonhoso escrever tais coisas.

[Koldun Zloy]

Dennis Kirichenko:

Artem, você está errado. O que você pode fazer sem meninas? - As meninas são todas nossas :-))

Mas, falando sério, eis o que quero discutir. Há uma classe onde o construtor de cópias é escrito e o operador da tarefa é anulado. Pergunta. Quando eles devem ser e devem ser diferentes?

O próprio compilador cria um simples construtor de cópias que simplesmente copia todos os membros da classe ou estrutura.

Se você quiser que outras ações sejam realizadas durante a cópia, você pode definir seu próprio construtor de cópias

e operador de atribuição.

O operador da atribuição é chamado para um objeto existente, portanto, ele deve primeiro verificar se a atribuição

se necessário, então libere o objeto existente e depois faça a mesma coisa que o construtor.