* esto hace una llamada al constructor?

Question

¿La operación en "este" puntero llama al constructor?

tengo un constructor definido de la siguiente manera

Cents(int cents) 
    { 
      cout<<"in cents constructor\n"; 
      m_cents = cents; 
    } 

    friend Cents operator + (const Cents &c1, const Cents &c2) 
    {   
      return Cents(c1.m_cents + c2.m_cents); 
    } 

    Cents operator ++ (int) 
    { 
      cout<<"In c++ function\n"; 
      Cents c(m_cents); 
      *this = *this + 1 ; 
      return c; 
    } 

en la función principal que tengo algo como ...

Cents c; 
    cout<<"Before post incrementing\n"; 
    c++; //This part is calling the constructor thrice 

Ahora Si estoy haciendo alguna operación como *this = *this + 1. Llama a este constructor dos veces.

¿Qué está pasando exactamente aquí? ¿*this crea un objeto temporal y asigna el valor al objeto original?

Answer 1

No, desmarcando un puntero no crea ningún objeto nuevo.

Hovever, si usted tiene operator+ definido únicamente para casos de su clase, habrá una nueva instancia construido a partir de1, porque el constructor Cents(int cents) no está marcado como explícito.

Answer 2

¡Aquí tiene lugar una gran cantidad de concursos!

Cents c; 

Esta línea llama Cents::Cents(), que es sintetizada por el compilador y no puede hacer lo que quiera que lo haga.

Luego de llamar:

Cents Cents::operator++(int) 

que devuelve un objeto de forma explícita y hace una llamada a Cents::Cents(int).

A continuación, realiza su tarea curiosa, lo que hace que la segunda llamada a Cents::Cents(int) para el segundo argumento.

Cuando se llama a Cents operator+(const Cents&, const Cents&) se construye explícitamente una nueva Cents::Cents(int) y devolver una copia del mismo ...

A continuación, se llama a la Cents& Cents::operator=(const Cents&) sintetizado, que de nuevo no puede hacer lo que quiera que lo haga.

Un operador típico post-incremento sería el siguiente:

Cents& operator++(int) 
{ 
    Cents rv = *this; 

    ++m_cents; 

    return rv; 
} 

Aviso cómo se devuelve el valor de la clase, ya que era antes del incremento llamando al constructor de copia (en lugar de una anulación) y también cómo aumenta los miembros de la clase individualmente.