A alocação dinâmica de um objeto com o construtor sobrecarregado em C++ [fechado]

Question

Fechado.Esta questão necessita de detalhes de espaço ou de clareza.Ele não está aceitando respostas.

---

Quer melhorar a esta questão? Adicionar detalhes e esclarecer o problema editar este post.

Fechado 5 anos atrás.

O que é a sintaxe para alocar dinamicamente um objeto com um construtor sobrecarregado em C++?

Se eu tenho uma classe Foo:

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

E uma segunda classe Foo2 (usando Foo):

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

O erro apresentado é o seguinte :

sem a correspondente função de chamada para "Foo::Foo()"

Como posso, ao criar myFoo ponteiro de objeto, especifique que ela irá utilizar o Foo(string str, int nbr) construtor, não Foo() construtor.

É possível sem o uso de construtor de delegação?

Answer 1

Sua sintaxe para construir o objecto está correto.

É difícil dizer com certeza, pois você ainda não disse o erro, mas o meu palpite é que o seu problema é que o construtor é privada.Isso significa que você não pode usar o construtor de fora da classe.

Editar relativa à mensagem de erro:

Aqui está um exemplo completo que compila.Eu adicionei algumas linhas de exemplo que iria gerar o erro:sem a correspondente função de chamada de '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 o erro, o seu código está tentando usar o construtor padrão em algum lugar.

Edit2 sobre o seu novo Foo2 exemplo.A sua declaração de Foo* e a chamada para o construtor ainda estão correctas e o código deve compilar se a corrigir o método de visibilidade e falta de ponto-e-vírgula.Seguinte exemplo 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

Sintaxe está correta.Há muitas possibilidades de como você não ter escrito completa definição de classe.1.verifique se o padrão cnstsructor está escrito.2.Verifique se ambos os construtores estão dentro da seção pública.3.Alternativamente, você pode alterar a chamada para o construtor como abaixo,

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

O seguinte código deve 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

A forma correcta é inicializar os membros de cada construtor.Você pode extrair o seu código comum em uma privada init() função de membro e chamá-lo em cada construtor como o seguinte:

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