Bauer in c Aufruf ++ ohne neue

Question

ich oft gesehen habe, dass Menschen Objekte in C++ zu erstellen

Thing myThing("asdf"); 

Statt dessen verwenden:

Thing myThing = Thing("asdf"); 

Dies scheint funktionieren (mit gcc), zumindest solange keine Vorlagen vorhanden sind. Meine Frage jetzt, ist die erste Zeile korrekt und wenn ja sollte ich sie verwenden?

Answer 1

Beide Zeilen sind in der Tat richtig, aber tun subtil verschiedene Dinge.

Die erste Zeile erstellt ein neues Objekt auf dem Stapel, indem ein Konstruktor des Formats Thing(const char*) aufgerufen wird.

Die zweite ist ein bisschen komplexer. Es spielt im Wesentlichen die folgenden

1. ein Objekt von Thing Typ Erstellen Sie den Konstruktor Thing(const char*)
2. ein Objekt von Thing Typ anlegen den Konstruktor Thing(const Thing&)
3. Anruf ~Thing() auf dem in Schritt # erstellte Objekt mit 1

Answer 2

Ganz einfach, beide Linien erstellen das Objekt auf dem Stapel, anstatt auf dem Haufen als 'neu'. Die zweite Zeile enthält tatsächlich einen zweiten Aufruf an einen Kopierkonstruktor, also sollte es vermieden werden (es muss auch korrigiert werden, wie in den Kommentaren angegeben). Sie sollten den Stapel für kleine Objekte so oft wie möglich verwenden, da er schneller ist. Wenn Ihre Objekte jedoch länger überleben als der Stapelrahmen, ist dies eindeutig die falsche Wahl.

Answer 3

Ich gehe davon mit der zweiten Zeile, die Sie tatsächlich bedeuten:

Thing *thing = new Thing("uiae"); 

, die der normale Weg der Schaffung neuer dynamische Objekte (notwendig für die dynamische Bindung und Polymorphismus) sein würde und die Speicherung ihrer Adresse auf einen Zeiger. Ihr Code macht das, was JaredPar beschrieben hat, nämlich das Erstellen zweier Objekte (eines übergab eine , das andere passierte eine const Thing&) und dann den Destruktor (~Thing()) auf dem ersten Objekt (const char*).

Dagegen folgt aus:

Thing thing("uiae"); 

ein statisches Objekt erzeugt, das beim Austritt aus dem aktuellen Bereich automatisch zerstört wird.

Answer 4

Idealerweise würde ein Compiler den zweiten optimieren, aber es ist nicht erforderlich. Der erste ist der beste Weg. Es ist jedoch sehr wichtig, den Unterschied zwischen Stack und Heap in C++ zu verstehen, da Sie Ihren eigenen Heap-Speicher verwalten müssen.

Answer 5

Der Compiler möglicherweise die zweite Form in die erste Form optimieren, aber es muss nicht.

#include <iostream> 

class A 
{ 
    public: 
     A() { std::cerr << "Empty constructor" << std::endl; } 
     A(const A&) { std::cerr << "Copy constructor" << std::endl; } 
     A(const char* str) { std::cerr << "char constructor: " << str << std::endl; } 
     ~A() { std::cerr << "destructor" << std::endl; } 
}; 

void direct() 
{ 
    std::cerr << std::endl << "TEST: " << __FUNCTION__ << std::endl; 
    A a(__FUNCTION__); 
    static_cast<void>(a); // avoid warnings about unused variables 
} 

void assignment() 
{ 
    std::cerr << std::endl << "TEST: " << __FUNCTION__ << std::endl; 
    A a = A(__FUNCTION__); 
    static_cast<void>(a); // avoid warnings about unused variables 
} 

void prove_copy_constructor_is_called() 
{ 
    std::cerr << std::endl << "TEST: " << __FUNCTION__ << std::endl; 
    A a(__FUNCTION__); 
    A b = a; 
    static_cast<void>(b); // avoid warnings about unused variables 
} 

int main() 
{ 
    direct(); 
    assignment(); 
    prove_copy_constructor_is_called(); 
    return 0; 
} 

Ausgabe von gcc 4.4:

Answer 6

Ich spielte ein wenig damit und die Syntax scheint ziemlich seltsam zu werden, wenn ein Konstruktor keine Argumente annimmt. Lassen Sie mich ein Beispiel geben:

#include <iostream> 

using namespace std; 

class Thing 
{ 
public: 
    Thing(); 
}; 

Thing::Thing() 
{ 
    cout << "Hi" << endl; 
} 

int main() 
{ 
    //Thing myThing(); // Does not work 
    Thing myThing; // Works 

} 

so das Schreiben nur Sache Mything w/o Klammern tatsächlich den Konstruktor aufruft, während Ding Mything() den Compiler, was macht Sie wollen einen Funktionszeiger oder etwas ?? schaffen !!

Answer 7

In append zu JaredPar Antwort

1-üblicher Ctor, 2.-Funktion-like-Ctor mit temporärem Objekt.

diese Quelle irgendwo Kompilieren hier http://melpon.org/wandbox/ mit verschiedenen Compilern

// turn off rvo for clang, gcc with '-fno-elide-constructors' 

#include <stdio.h> 
class Thing { 
public: 
    Thing(const char*){puts(__FUNCTION__);} 
    Thing(const Thing&){puts(__FUNCTION__);} 
    ~Thing(){puts(__FUNCTION__);} 
}; 
int main(int /*argc*/, const char** /*argv*/) { 
    Thing myThing = Thing("asdf"); 
} 

Und Sie werden sehen das Ergebnis.

Von ISO/IEC 14882 2003-10-15

8,5, Teil 12

Ihr erstes werden 2. Aufbau Direkt Initialisierung

12,1, Teil 13 genannt

Eine Konvertierung der funktionalen Notation (5.2.3) kann verwendet werden, um zu erstellen neue Objekte seines Typs. [Hinweis: Die Syntax sieht wie ein expliziter Aufruf des Konstruktors aus. ] ... Ein auf diese Weise erstelltes Objekt ist unbenannt. [Anmerkung: 12.2 beschreibt die Lebensdauer von temporären Objekten. ] [Hinweis: Explizite Konstruktoraufrufe ergeben keine lvalues, siehe 3.10.

]

---

Wo etwa RVO lesen:

12 Spezielle Mitgliederfunktionen/12.8 Kopieren von Klassenobjekten/Part 15

Wenn bestimmte Kriterien erfüllt sind, wird eine Implementierung erlaubt wegzulassen der Kopieraufbau eines Klassenobjekts, sogar, wenn der Kopierkonstruktor und/oder destructor für das Objekt hat Nebenwirkungen.

Schalten Sie es mit Compiler-Flag von Kommentar solche Kopie-Verhalten)