La asignación dinámica de un objeto con constructor sobrecargado en C++ [cerrado]

Question

Cerrado.Esta pregunta necesidades los detalles o la claridad.Actualmente, no es la aceptación de respuestas.

---

Desea mejorar esta pregunta? Agregar detalles y aclarar el problema la edición de este post.

Cerrado Hace 5 años.

¿Cuál es la sintaxis para asignar dinámicamente un objeto con un constructor sobrecargado en C++?

Si tengo una clase Foo:

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

Y una segunda clase Foo2 (utilizando Foo):

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

El error que aparece es la siguiente :

no coincidencia de la función para llamar a "Foo::Foo()"

¿Cómo puedo yo, a la hora de crear myFoo puntero de objeto, especificar que se utilice el Foo(string str, int nbr) constructor, no Foo() constructor.

Es posible sin utilizar el constructor de la delegación?

Answer 1

Su sintaxis para construir el objeto es correcta.

Es difícil decir con certeza, ya que no ha dicho el error, pero mi conjetura es que su problema es que el constructor es privado.Eso significa que usted no puede utilizar el constructor fuera de la clase.

Editar sobre el mensaje de error:

He aquí un ejemplo completo en el que se compila.He añadido algunas líneas de ejemplo que se iba a producir el error:no coincidencia de la función de llamada 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
}

Dado el error, el código está tratando de utilizar el constructor por defecto en algún lugar.

Edit2 sobre su nuevo Foo2 ejemplo.Su declaración de Foo* y la llamada al constructor todavía son correctos y el código debe compilar si corrige el método de la visibilidad y la falta de puntos y comas.Ejemplo siguiente se 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

sintaxis es correcta. Hay muchas posibilidades, ya que no ha escrito definición de clase completa. 1. Compruebe si se escribe CNSTSRUTOR predeterminado. 2. Compruebe si ambos constructores están dentro de la sección pública. 3. Alternativamente, puede cambiar la llamada al constructor como a continuación,

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

El siguiente código debería funcionar.

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

La forma correcta está inicializando a los miembros en cada constructor.Puede extraer su código común en una función de miembro de inicio () privado y llámelo en cada constructor como el siguiente:

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)
{
    ...
}