Appel de constructeurs en C ++ sans nouveau

J'ai souvent vu que les gens créent des objets en C ++ en utilisant

Thing myThing("asdf");

Au lieu de cela:

Thing myThing = Thing("asdf");

Cela semble fonctionner (en utilisant gcc), du moins tant qu'il n'y a pas de modèles impliqués. Ma question maintenant, est-ce que la première ligne est correcte et si oui, dois-je l'utiliser?

Les deux lignes sont en fait correctes mais font des choses subtilement différentes.

La première ligne crée un nouvel objet sur la pile en appelant un constructeur du format Thing(const char*).

Le second est un peu plus complexe. Il fait essentiellement ce qui suit

1. Créer un objet de type Thingà l'aide du constructeurThing(const char*)
2. Créer un objet de type Thingà l'aide du constructeurThing(const Thing&)
3. Appelez ~Thing()l'objet créé à l'étape 1

Je suppose qu'avec la deuxième ligne, vous voulez dire:

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

qui serait la manière standard de créer de nouveaux objets dynamiques (nécessaires pour la liaison dynamique et le polymorphisme) et de stocker leur adresse dans un pointeur. Votre code fait ce que JaredPar a décrit, à savoir créer deux objets (l'un a passé a const char*, l'autre a passé a const Thing&), puis appeler le destructeur ( ~Thing()) sur le premier objet ( const char*celui).

En revanche, ceci:

Thing thing("uiae");

crée un objet statique qui est détruit automatiquement à la sortie de la portée actuelle.

Le compilateur peut très bien optimiser la deuxième forme dans la première forme, mais ce n'est pas obligatoire.

#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;
}

Sortie de gcc 4.4:

TEST: direct
char constructor: direct
destructor

TEST: assignment
char constructor: assignment
destructor

TEST: prove_copy_constructor_is_called
char constructor: prove_copy_constructor_is_called
Copy constructor
destructor
destructor

Tout simplement, les deux lignes créent l'objet sur la pile, plutôt que sur le tas comme le fait «new». La deuxième ligne implique en fait un deuxième appel à un constructeur de copie, donc cela doit être évité (il doit également être corrigé comme indiqué dans les commentaires). Vous devriez utiliser la pile pour les petits objets autant que possible car elle est plus rapide, mais si vos objets vont survivre plus longtemps que le cadre de la pile, alors c'est clairement le mauvais choix.

Idéalement, un compilateur optimiserait le second, mais ce n'est pas obligatoire. Le premier est le meilleur moyen. Cependant, il est assez critique de comprendre la distinction entre pile et tas en C ++, sine vous devez gérer votre propre mémoire de tas.

J'ai joué un peu avec et la syntaxe semble devenir assez étrange lorsqu'un constructeur ne prend aucun argument. Laissez-moi vous donner un exemple:

#include <iostream> 

using namespace std;

class Thing
{
public:
    Thing();
};

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

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

}

donc juste écrire Thing myThing sans crochets appelle le constructeur, tandis que Thing myThing () fait du compilateur ce que vous voulez créer un pointeur de fonction ou quelque chose ?? !!

En annexe à JaredPar réponse

1-ctor habituel, 2nd-function-like-ctor avec un objet temporaire.

Compilez cette source quelque part ici http://melpon.org/wandbox/ avec différents compilateurs

// 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");
}

Et vous verrez le résultat.

D'après ISO / CEI 14882 2003-10-15

8.5, partie 12

Votre 1ère, 2ème construction s'appelle l'initialisation directe

12.1, partie 13

Une conversion de type de notation fonctionnelle (5.2.3) peut être utilisée pour créer de nouveaux objets de son type. [Note: La syntaxe ressemble à un appel explicite du constructeur. ] ... Un objet ainsi créé est sans nom. [Remarque: 12.2 décrit la durée de vie des objets temporaires. ] [Remarque: les appels de constructeur explicites ne donnent pas de valeurs l, voir 3.10. ]

Où lire sur RVO:

12 Fonctions membres spéciales / 12.8 Copie d'objets de classe / Partie 15

Lorsque certains critères sont remplis, une implémentation est autorisée à omettre la construction de copie d'un objet de classe, même si le constructeur de copie et / ou le destructeur de l'objet ont des effets secondaires .

Désactivez-le avec l'indicateur du compilateur du commentaire pour afficher un tel comportement de copie)