Allocazione dinamica di un oggetto con costruttore sovraccarico in C++ [chiuso]

Question

Chiuso.Questa domanda ha bisogno di dettagli o chiarezza.Attualmente non accetta risposte.

---

Vuoi migliorare questa domanda? Aggiungere dettagli e chiarire il problema modifica questo post.

Chiuso 5 anni fa.

Qual è la sintassi per allocare dinamicamente un oggetto con un costruttore sovraccarico in C++?

Se ho una classe Foo:

class Foo{
public:
    Foo(string str, int nbr);    // Overloaded constructor
};

E un Foo2 di seconda classe (usando Foo):

#include "Foo"
class Foo2{
public:
    Foo* myFoo;    // Wrong!
    Foo2(){
        myFoo = new Foo(myStr, myNbr);
    }
};

L'errore visualizzato è il seguente :

nessuna funzione corrispondente per la chiamata a " Foo:: Foo ()"

Come posso, quando creo myFoo object pointer, specificare che userà il Foo(string str, int nbr) costruttore, non Foo() costruttore.

È possibile senza utilizzare la delega del costruttore?

Answer 1

La sintassi per costruire l'oggetto è corretta.

È difficile dirlo con certezza dal momento che non hai detto l'errore, ma la mia ipotesi è che il tuo problema sia che il costruttore sia privato.Ciò significa che non è possibile utilizzare il costruttore al di fuori della classe.

Modifica riguardante il messaggio di errore:

Ecco un esempio completo che compila.Ho aggiunto alcune righe di esempio che produrrebbero l'errore:nessuna funzione corrispondente per la chiamata a ' Foo:: Foo ()'.

#include <string>

class Foo{
public:
    Foo(std::string str, int nbr);
};

// empty definition
Foo::Foo(std::string str, int nbr) {}

// delegating constructor (c++11 feature)
// this would produce error: no matching function for call to 'Foo::Foo()'
//Foo::Foo(std::string str, int nbr) : Foo::Foo() {}

int main() {
    Foo* myFoo;
    myFoo = new Foo("testString", -1); // this is correct
    // trying to construct with default constructor
    //Foo myFoo2; // this would produce error: no matching function for call to 'Foo::Foo()'
    //Foo* myFoo3 = new Foo(); // so would this
}

Dato l'errore, il codice sta tentando di utilizzare il costruttore predefinito da qualche parte.

Edit2 riguardo al tuo nuovo Foo2 esempio.La tua dichiarazione di Foo * e la chiamata al costruttore sono ancora corrette e il codice dovrebbe essere compilato se si corregge la visibilità del metodo e il punto e virgola mancanti.Il seguente esempio compila:

#include <string>

class Foo{
public:
    Foo(std::string str, int nbr);    // Overloaded constructor
};

Foo::Foo(std::string str, int nbr){}

class Foo2{
    Foo* myFoo;    // This is still correct
public:
    Foo2() {
        myFoo = new Foo("", 1);
    }
};

int main() {
    Foo2 foo2;
}

Answer 2

La sintassi è corretta.Ci sono molte possibilità in quanto non hai scritto la definizione completa della classe.1.verificare se cnstsructor predefinito è scritto.2.Controlla se entrambi i costruttori si trovano all'interno della sezione pubblica.3.In alternativa è possibile modificare la chiamata al costruttore come di seguito,

Foo* myFoo = new Foo("testString", -1);

Il seguente codice dovrebbe funzionare.

class Foo
{

string str;
int num;
public:
    Foo(string p_str, int nbr):str(p_str),num(nbr){};    // Overloaded constructor
    Foo() {};    // Default constructor
};

Answer 3

Il modo corretto è inizializzare i membri in ciascun costruttore.È possibile estrarre il loro codice comune in una funzione membro init() privata e chiamarla in ogni costruttore come segue:

class Foo {
    public:
        Foo(string x);
        Foo(string x, int y);
        ...
    private:
        void init(string x, int y);
};

Foo::Foo(string x)
{
    init(x, int(x) + 3);
    ...
}

Foo::Foo(string x, int y)
{
    init(x, y);
    ...
}

void Foo::init(string x, int y)
{
    ...
}