Initialisation de la valeur d'un objet automatique ?

Question

Je suis en train d'écrire une classe template et à un moment de mon code, j'aimerais pouvoir initialiser un objet du type paramétré sur la pile. Pour l'instant, j'y parviens en écrivant quelque chose comme ceci :

template <typename T> void MyClass<T>::doSomething() {
    T valueInitialized = T();
    /* ... */
}

Ce code fonctionne, mais (à moins que le compilateur ne soit intelligent) il nécessite la création et la destruction inutiles du fichier temporaire T objet. Ce que je voudrais écrire est ce qui suit, que je sais être incorrect :

template <typename T> void MyClass<T>::doSomething() {
    T valueInitialized(); // WRONG: This is a prototype!
    /* ... */
}

Ma question est de savoir s'il existe un moyen efficace d'initialiser la valeur de l'objet automatique sans avoir à construire explicitement un objet temporaire et à l'assigner à l'objet automatique. Est-ce possible ? Ou est-ce que T var = T(); aussi bon qu'il puisse l'être ?

Answer 1

Les utilisations suivantes Copie-initialisation ce qui est "probablement bien" dans 95 % des cas en C++03 :

T var = T();

Mais pour générique (C++03), vous devriez toujours préférer le code initialisation directe pour tenir compte des 5 % restants :

T var((T())); // extra parentheses avoid the most vexing parse – the extra parentheses
              // force the contents to be evaluated as an expression, thus implicitly
              // *not* as a declaration.

Ou mieux encore, utilisez la fonction Boost . Utility.ValueInit qui regroupe le comportement idéal pour vous ainsi que des solutions de contournement pour diverses déficiences du compilateur (malheureusement, plus nombreuses qu'on ne le pense) :

boost::value_initialized<T> var;

---

En C++11, il est possible d'utiliser la syntaxe d'initialisation de liste pour réaliser l'initialisation de valeur directe d'une manière nettement moins bruyante :

T var{}; // unambiguously value-initialization†

( † N.B. : techniquement, cette procédure invoquera le principe du std::initializer_list<> au lieu de procéder à l'initialisation de la valeur pour certains types pathologiques. On peut supposer que le résultat net devrait être le même).

Answer 2

Vous pouvez utiliser des accolades en C++0x :

T valueInitialized{};

Answer 3

Non, il n'y a pas d'autre moyen d'initialiser de manière fiable un type template en C++03.

Si vous pouvez compter sur T n'étant que des types de classes avec des constructeurs par défaut, vous pourriez simplement écrire

T valueInitialized;

mais si T pourrait tout aussi bien être un type intégré,

T valueInitialized = T();

est la voie à suivre.

Avez-vous une raison de ne pas faire confiance à votre compilateur pour optimiser cette copie ?