[C++] Conflitti tra costruttore di copia e operatore di assegnamento

[Zero-Giulio]

Per esporre il mio problema, incollo subito una classe semplice (ridotta al midollo):

class obj {

    private:

        int arg1;

    public:

        obj ()
            : arg1 (1) {}

        obj (const string & s)
            : arg1 (15) {}

        const obj & operator = (const obj & p) {
            arg1 = p.arg1;
            return *this;
        }

        const obj & operator = (const string & s) {
            arg1 = 15;
            return *this;
        }

        int get () {
            return arg1;
        }

        void set (int arg) {
            arg1 = arg;
        }

};

La mia domanda è molto semplice:

perchè

obj p;
p = "ciao";

funziona, e

obj p ("ciao");

funziona pure, mentre

obj p = "ciao";

non funziona?

[DanieleC88]

Perché la tua prima versione chiama il costruttore obj::obj() e poi, una volta costruito l'oggetto, chiama il metodo obj::operator=(const std::string&), costruendo dinamicamente un oggetto std::string a partire dal const char[] che provi ad assegnarvi. (Esiste un costruttore di std::string che accetta un const char*, per cui tutto ciò è fattibile.)
La seconda versione invece cerca di costruire l'oggetto dando come argomento del costruttore un const char[]: per gli stessi motivi di prima, ciò riesce con il costruttore obj::obj(const std::string&).
La terza invece cerca di utilizzare un costruttore di copia. Siccome un const char* non è un'istanza di obj valida, il compilatore dovrebbe tentare di costruire prima un'istanza di obj passando come argomento al costruttore un const char*, il che però non è possibile visto che non esiste un costruttore che lo accetti come parametro.

Il punto è che ci vorrebbero due passaggi anziché uno per invocare il costruttore:

1. parti da un const char*
2. costruisci un'istanza di std::string usando std::string::string(const char*)
3. costruisci un'istanza di obj usando obj::obj(std::string&), con riferimento all'istanza di std::string costruita al passo precedente
4. invochi il costruttore di copia di obj

Il passaggio critico è dato dal fatto che il compilatore cercherà implicitamente di tradurre la tua dichiarazione in:

obj p = obj("ciao");

e non in:

obj p = obj(std::string("ciao"));

come invece c'è bisogno di fare. Il compilatore non ha diritto di prendere questa decisione per te, e mancando un costruttore adatto ti sputa fuori l'errore di compilazione.

Diciamo che puoi risolvere in due modi: o aggiungi un costruttore di obj che accetti un const char*, facendo così scomparire l'errore alla radice, oppure costruisci esplicitamente un'istanza di std::string da passare implicitamente al costruttore:

obj p = std::string("ciao");

ciao

[Zero-Giulio]

Continuo ad avere dubbi.
Sapevo che

obj p = "ciao";

veniva tradotto in

obj p = obj ("ciao");

ma non capisco poi quale sia il problema.
Infatti

obj ("ciao")

è una cosa che il compilatore riesce a fare (capisce che deve trasformare il char * in string), infatti

obj p ("ciao")

funziona, e anche l'operatore di assegnamento funziona.
Non capisco qual'è la differenza, perchè qui

obj p ("ciao")

il compilatore capisce che deve trasformare un char * in una string mentre in

obj p = obj ("ciao")

non lo capisce?
Perchè il copy constructor una volta è intelligente e una volta no?

[DanieleC88]

No, vedi che ho già risposto a quello che mi chiedi...

Se tu dici:

obj p("ciao");

allora il compilatore cerca il costruttore più adatto. Siccome non c'è un costruttore che accetti un const char[], ripiega su quello che accetta un std::string. Questo lo fa perché esiste un costruttore di std::string che accetti un const char*, e quindi non ha di che lamentarsi. Il compilatore, dunque, pensa:

obj p(std::string("ciao"));

In questo caso, il passaggio implicito è la costruzione di un oggetto di tipo std::string, perché tutto il resto è già fornito al compilatore.

Quando, invece, tu dici:

obj p = "ciao";

il compilatore pensa:

obj p = obj("ciao");

e basta: quindi, nessun adattamento di "ciao", che è un const char[], ad un std::string. In questo caso, il passaggio implicito è la costruzione di un oggetto di tipo obj, ma non è sufficiente: ci vorrebbe infatti un secondo passaggio implicito, che è quello della costruzione di un oggetto std::string a partire dal const char[].

Nel caso precedente il compilatore doveva fare una sola decisione (e la fa), in quest'ultimo caso invece ne dovrebbe fare due, una conseguenza dell'altra.
Se tu potessi fare più di una "scelta" di questo tipo, allora ne dovresti poter fare a catena: potevi ad esempio scrivere una cosa del genere:

obj p = 123;

ed aspettarti che venga "trasformata" dal compilatore in:

obj p = "123";

e quindi, ancora, in:

obj p = std::string("123");

O no?