Dynamische Zuordnung eines Objekts mit überladenem Konstruktor in C++ [geschlossen]

Question

Geschlossen.Diese Frage braucht Details oder Klarheit.Derzeit werden keine Antworten akzeptiert.

---

Möchten Sie diese Frage verbessern? Fügen Sie Details hinzu und klären Sie das Problem durch diesen Beitrag bearbeiten.

Geschlossen vor 5 Jahren.

Wie lautet die Syntax für die dynamische Zuweisung eines Objekts mit einem überladenen Konstruktor in C++?

Wenn ich eine Klasse Foo habe:

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

Und ein Foo2 der zweiten Klasse (mit Foo):

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

Der angezeigte Fehler ist der folgende:

Keine passende Funktion für Aufruf von „Foo::Foo()“

Wie kann ich beim Erstellen des myFoo-Objektzeigers angeben, dass dieser verwendet wird? Foo(string str, int nbr) Konstruktor, nicht Foo() Konstrukteur.

Ist es möglich, ohne die Konstruktordelegierung zu verwenden?

Answer 1

Ihre Syntax zum Erstellen des Objekts ist korrekt.

Es ist schwer, es mit Sicherheit zu sagen, da Sie den Fehler nicht angegeben haben, aber ich vermute, dass Ihr Problem darin liegt, dass der Konstruktor es ist Privat.Das bedeutet, dass Sie den Konstruktor nicht außerhalb der Klasse verwenden können.

Edit zur Fehlermeldung:

Hier ist ein vollständiges Beispiel, das kompiliert wird.Ich habe einige Beispielzeilen hinzugefügt, die den Fehler erzeugen würden:Keine passende Funktion für den Aufruf von „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
}

Aufgrund des Fehlers versucht Ihr Code, den Standardkonstruktor zu verwenden irgendwo.

Edit2 bezüglich Ihres neuen Foo2 Beispiel.Ihre Deklaration von Foo* und der Aufruf des Konstruktors sind immer noch korrekt und der Code sollte kompiliert werden, wenn Sie die Sichtbarkeit der Methode und fehlende Semikolons korrigieren.Das folgende Beispiel wird kompiliert:

#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

Die Syntax ist korrekt.Es gibt viele Möglichkeiten, da Sie keine vollständige Klassendefinition geschrieben haben.1.Überprüfen Sie, ob der Standard-cnstsructor geschrieben ist.2.Überprüfen Sie, ob sich beide Konstruktoren im öffentlichen Abschnitt befinden.3.Alternativ können Sie den Aufruf des Konstruktors wie folgt ändern:

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

Der folgende Code sollte funktionieren.

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

Der richtige Weg besteht darin, die Mitglieder in jedem Konstruktor zu initialisieren.Sie könnten ihren gemeinsamen Code in einer privaten init()-Mitgliedsfunktion extrahieren und ihn in jedem Konstruktor wie folgt aufrufen:

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