Allocazione dinamica di un oggetto con costruttore sovraccarico in C++ [chiuso]
-
23-12-2019 - |
Domanda
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?
Soluzione
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;
}
Altri suggerimenti
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
};
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)
{
...
}