Wie zum initialisieren einen Konstruktor mit nimmt, dass Strings als Parameter?

Ich bin nicht sicher, dass ich mich mit der richtigen Terminologie, aber die Frage ist, wie muss ich richtig stellen Sie einen Konstruktor nimmt einen string als parameter?

Bin ich verwendet, um mit einem const char * im Konstruktor statt des strings.

Normalerweise würde ich so etwas tun:

Name(const char* fName, const char* lName)
    : firstName(0), lastName(0)
{
    char * temp = new char [strlen(fName) + 1];
    strcpy_s(temp, strlen(fName) + 1, fName);
    firstName = temp;

    char * temp2 = new char [strlen(lName) + 1];
    strcpy_s(temp2, strlen(lName) + 1, lName);
    lastName = temp2;
}

Was ist, wenn der Konstruktor ist:

 Name(const string fName, const string lName) { }

Tun habe ich immer noch Basis-member-Initialisierung? noch muss ich die Verwendung von string Kopie in der Basis der Konstruktor?

InformationsquelleAutor Sarah | 2013-11-05
  1. 12

    Verwenden std::string und Initialisierer-Listen:

    std::string fName, lName;

Name(string fName, string lName):fName(std::move(fName)), lName(std::move(lName))
{
}

    In diesem Fall, Sie brauchen nicht zu verwenden, schrecklich bare Zeiger, die Sie nicht brauchen, Speicher, Zeichen kopieren, und schließlich de-allocate. Darüber hinaus ist dieser neue code hat Chancen, um die Vorteile verschieben statt kopieren seit std::string ist beweglich. Auch ist es nützlich zu Lesen diese.

    Und so weiter....

    • Warum sollte ich nicht initialisieren, um " 0 " als würde ich mit char *?
    • Weil std::string-Objekte sind eigentlich nicht 0 sein, denn es sind Objekte (keine Verweise). Sie sind leer, wie im Sinne von "".
    • Neben Martijn Kommentar, obigen code ist die Initialisierung und kopieren gleichzeitig. Sie brauchen nichts anderes.
    • Der obige code könnte tatsächlich entstehen mindestens 2 Kopien, sofern Sie nicht explizit angeben std::move in der Initialisierungsliste. Außerdem ist dies ein gutes Beispiel für move-Semantik, da Sie nur noch 1 Exemplar; genau das gleiche wie wenn Sie benutzt hatte, einen Verweis.
    • Ja, du hast Recht, ich weiß nicht, warum ich vergessen std::move
    InformationsquelleAutor deepmax
  2. 9

    Ich sehe, dass Sie bereits akzeptiert haben, eine Antwort aber ich würde gerne erweitern auf die Antworten.

    Als deepmax sagte, wenn Sie von Wert schreiben Sie den Konstruktor nutzen, der "move-Semantik". Dies bedeutet, dass anstelle von kopieren von Daten, kann es bewegt werden von einer Variablen zu einer anderen.

    Geschrieben, etwa so:

    class Name{
    public:
        Name(std::string var): mem_var(std::move(var)){}

        std::string mem_var;
};

    Scheint wie eine gute Idee, aber in Wirklichkeit ist es nicht effizienter ist als der copy-Konstruktor

    class Name{
    public:
        Name(const std::string &var): mem_var(var){}

        std::string mem_var;
};

    Der Grund dafür ist, weil in den Allgemeinen Anwendungsfall sieht wie folgt aus:

    auto main() -> int{
    Name name("Sample Text");
}

    nur eine Kopie immer bekommen, entweder Weg (siehe copy elision), und im anderen Fall von

    auto main() -> int{
    std::string myname = "Hugh Jaynus";
    Name name(myname);
}

    2 Kopien gemacht werden, die "effizient" pass-by-value move-Semantik Weg!

    Dies ist ein gutes Beispiel, wenn der copy-Konstruktor (oder pass-by-reference) sollte verwendet werden, nicht ein Beispiel gegen Sie.

    Im Gegenteil...

    Wenn Sie schreiben, ein expliziter Konstruktor, der move-Semantik konnte man sich eine effiziente Lösung, egal die Umstände.

    Hier ist, wie Sie schreiben, einen Namen Klassendefinition mit den beiden Konstruktoren:

    class Name{
    public:
        Name(const std::string &first_, const std::string &last_)
            : first(first_), last(last_){}

        Name(std::string &&first_, std::string &&last_) //rvalue reference
            : first(std::move(first_)), last(std::move(last_)){}

        std::string first, last;
};

    Dann, wenn Sie die Klasse verwenden, die effizienter Weg genommen werden sollte.

    Wenn wir gehen zurück auf unsere Beispiele, die wir umschreiben können, Sie zu nutzen, die besten oder effizientesten Konstruktor:

    int main(){
    //pass by reference best here
    Name myname("Yolo", "Swaggins");

    //move most efficient here
    //but never use 'first' and 'last' again or UB!
    std::string first = "Hugh", last = "Jaynus";
    Name yourname(std::move(first), std::move(last));
}

    Nie einfach für selbstverständlich zu nehmen, dass eine Lösung besser ist als alle anderen!

    InformationsquelleAutor CoffeeandCode
  3. 3

    Bin ich verwendet, um dies zu tun:

    std::string fName;
std::string lName;

Name(const std::string &fName, const std::string &lName) :
     fName(fName), lName(lName)
{
}

    Mithilfe der Verweise spart die Arbeit des Kopierens des strings in ein neues Objekt auf dem stack, es wird einfach die Referenz auf den vorhandenen string. Sobald Sie die Zuordnung zu den Klasse Mitgliedern, Sie werden kopiert.

    • Warum Sie sich nicht über Wert, wenn Sie Bedenken Effizienz?
    • aber was ist, wenn ich nicht mit Referenzen auf strings in meinen Parametern?
    • Ich schrieb in meiner Antwort: weil Sie nicht so einfach kopiert werden, indem man Sie an den Konstruktor übergeben. Der Konstruktor wird, kopieren Sie als gut, in jedem Fall (mit oder ohne Referenzen).
    • Gut, dann sind Sie entweder stick mit Ihrer aktuellen situation oder zu ändern, es zu const-Referenzen.
    • Move-Semantik (C++11) etwas anderes sagen, Lesen Sie diesem Artikel.
    • Ich habe den Artikel gelesen, und wenn ich das richtig verstanden, es gibt nur performance-Gewinne in bestimmten situation. Dies gilt nicht, glaube ich? Die endgültige Kopie von der Methode als argument der Klassen-member können nie vermieden werden, richtig? Bei der Verwendung von Referenzen, und dies zu tun: new Name(getSomeString(), getSomeString()) würden, hätten wir zwei Exemplare pro argument: 1) aus getSomeString() aufgerufene, 2) von der aufgerufenen Funktion an die Schüler. Wenn wir das gleiche Taten, mithilfe des pass by value), wir würden nur eine Kopie: von getSomeString() der Klasse Mitglied. Hab ich das richtig verstanden?
    • Wenn Sie als Wert übergeben, im Falle der vorübergehenden übergebenen Objekte (z.B. Name name("Martijn","Courteaux");) es wird move die Werte, und Sie haben keine Kopie. Im Falle der nicht-temporären Objekte übergeben (z.B. Name name(fn, ln);) Sie haben eine Kopie als identisch mit der übergabe by reference. Summary: als Wert Übergeben werden, können unnötige Kopien für temp-Objekte. Daher ist es logisch zu bevorzugen es.
    • Auch die Antwort SO sinnvoll ist.
    • Ich verstehe, dass. Aber das scheint logisch für mich, denn das erstellen Name name - Objekt auf dem Stapel, so kann der compiler nur legte es sofort an der richtigen position. Aber ich redete ein new-ly erstellte Objekt (auf dem heap).
    • Also, zu Fragen, in einer klaren Art und Weise: Beim erstellen eines new Name("Martijn", "Courteaux"); (new, also auf dem heap). Es würde nicht keinen Unterschied machen, wenn wir haben pass-by-value oder by reference, richtig? Es kopieren müsste beide Male einmal?
    • Es hängt nicht von Name ist auf stack oder heap. Pass-by-value hat die chance, sich zu bewegen, diese Namen auf die Schüler, anstatt Sie zu kopieren.

    InformationsquelleAutor Martijn Courteaux
  4. 0

    wenn Sie behalten möchten, const char * als Konstruktor-input-Typen tun dies.

    std::string fName;
std::string lName;

Name(const char *_fName, const char *_lName) :
     fName(_fName), lName(_lName)
{
}

    Können Sie konstruieren eine std::string aus const char.

    • Bezeichner beginnen mit einem Unterstrich am Anfang sind reserviert der compiler, Sie soll Sie haben trailing.
    InformationsquelleAutor Mark Hendrickson
Schreibe einen Kommentar