* effettua una chiamata al costruttore?

Question

L'operazione su "questo" puntatore chiama il costruttore?

ho un costruttore definito come segue

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; 
    } 

nella funzione principale che ho STH come ...

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

Ora, se io sto facendo qualche operazione come *this = *this + 1. Chiama questo costruttore due volte.

Che cosa sta succedendo esattamente qui. *this crea un oggetto temporaneo e assegna il valore all'oggetto originale?

Answer 1

No, il dereferenziamento di un puntatore non crea alcun nuovo oggetto.

Hovever, se avete operator+ definito solo per le istanze della classe, ci sarà una nuova istanza costruita1, poiché il costruttore Cents(int cents) non è contrassegnato come esplicito.

Answer 2

Hai un sacco di programmi in corso qui!

Cents c; 

Questa linea chiama Cents::Cents(), che è sintetizzato dal compilatore e non può fare ciò che si desidera.

quindi si chiama:

Cents Cents::operator++(int) 

che restituisce un oggetto e in modo esplicito effettua una chiamata a Cents::Cents(int).

Quindi esegui il tuo curioso incarico, che effettua la seconda chiamata a Cents::Cents(int) per il secondo argomento.

Quando si chiama Cents operator+(const Cents&, const Cents&) si costruisce in modo esplicito uno nuovo Cents::Cents(int) e restituire una copia di esso ...

quindi si chiama il sintetizzata Cents& Cents::operator=(const Cents&), che ancora una volta non può fare ciò che si desidera.

Un tipico operatore di post-incremento sarebbe simile a questa:

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

    ++m_cents; 

    return rv; 
} 

Notate come restituisce il valore della classe come era prima l'incremento chiamando il costruttore di copia (piuttosto che una sostituzione) e anche come incrementa i membri della classe individualmente.