Allocation dynamique d'un objet avec constructeur surchargé en C++ [fermé]

Question

Fermé.Cette question nécessite détails ou clarté.Il n’accepte actuellement pas de réponses.

---

Vous souhaitez améliorer cette question ? Ajoutez des détails et clarifiez le problème en éditer ce message.

Fermé il y a 5 ans.

Quelle est la syntaxe pour allouer dynamiquement un objet avec un constructeur surchargé en C++ ?

Si j'ai une classe Foo :

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

Et un Foo2 de deuxième classe (utilisant Foo) :

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

L'erreur affichée est la suivante :

aucune fonction correspondante pour l'appel à "Foo::Foo()"

Comment puis-je, lors de la création du pointeur d'objet myFoo, spécifier qu'il utilisera le Foo(string str, int nbr) constructeur, pas Foo() constructeur.

Est-ce possible sans utiliser la délégation du constructeur ?

Answer 1

Votre syntaxe pour construire l'objet est correcte.

C'est difficile à dire avec certitude puisque vous n'avez pas indiqué l'erreur, mais je suppose que votre problème est que le constructeur est privé.Cela signifie que vous ne pouvez pas utiliser le constructeur en dehors de la classe.

Edit concernant le message d'erreur :

Voici un exemple complet qui compile.J'ai ajouté quelques exemples de lignes qui produiraient l'erreur :aucune fonction correspondante pour l'appel à '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
}

Compte tenu de l'erreur, votre code essaie d'utiliser le constructeur par défaut quelque part.

Edit2 concernant votre nouveau Foo2 exemple.Votre déclaration de Foo* et l'appel au constructeur sont toujours corrects et le code devrait se compiler si vous corrigez la visibilité de la méthode et les points-virgules manquants.L'exemple suivant compile :

#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 syntaxe est correcte.Il existe de nombreuses possibilités car vous n'avez pas écrit de définition complète de la classe.1.vérifiez si le constructeur par défaut est écrit.2.Vérifiez si les deux constructeurs se trouvent dans la section publique.3.Alternativement, vous pouvez modifier l'appel au constructeur comme ci-dessous,

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

Le code suivant devrait fonctionner.

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 bonne manière consiste à initialiser les membres de chaque constructeur.Vous pouvez extraire leur code commun dans une fonction membre privée init() et l'appeler dans chaque constructeur comme suit :

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