Value-initialization

Ceci est l'initialisation effectuée lorsqu'un objet est construit avec un initialiseur vide.

Syntaxe

Explication

L'initialisation par valeur est effectuée dans ces situations :

Dans tous les cas, si la paire d'accolades vide {} est utilisée et que T est un type agrégé, l'initialisation agrégée est effectuée au lieu de l'initialisation par valeur.

Les effets de l'initialisation par valeur sont :

• Si T est un type classe (éventuellement qualifié cv) :

• Si l'initialisation par défaut pour T sélectionne un constructeur , et que le constructeur n'est pas déclaré par l'utilisateur (jusqu'à C++11) fourni par l'utilisateur (depuis C++11) , l'objet est d'abord initialisé à zéro .
• Dans tous les cas, l'objet est initialisé par défaut .

• Sinon, si T est un type tableau, chaque élément du tableau est initialisé par valeur.
• Sinon, l'objet est initialisé à zéro.

Notes

La syntaxe T object ( ) ; n'initialise pas un objet ; elle déclare une fonction qui ne prend aucun argument et retourne T . La manière de value-initialize une variable nommée avant C++11 était T object = T ( ) ; , ce qui value-initialize un temporaire puis copy-initialize l'objet : la plupart des compilateurs optimisent la copie dans ce cas.

Les références ne peuvent pas être initialisées par valeur.

Comme décrit dans la conversion de type fonction , la syntaxe T ( ) (1) est interdite si T désigne un type tableau, tandis que T { } (5) est autorisée.

Tous les conteneurs standards ( std::vector , std::list , etc.) initialisent par valeur leurs éléments lorsqu'ils sont construits avec un seul argument size_type ou lorsqu'ils sont agrandis par un appel à resize ( ) , sauf si leur allocateur personnalise le comportement de construct .

Exemple

#include <cassert>
#include <iostream>
#include <string>
#include <vector>
struct T1
{
    int mem1;
    std::string mem2;
    virtual void foo() {} // assure que T1 n'est pas un agrégat
}; // constructeur par défaut implicite
struct T2
{
    int mem1;
    std::string mem2;
    T2(const T2&) {} // constructeur de copie fourni par l'utilisateur
};                   // pas de constructeur par défaut
struct T3
{
    int mem1;
    std::string mem2;
    T3() {} // constructeur par défaut fourni par l'utilisateur
};
std::string s{}; // classe => initialisation par défaut, la valeur est ""
int main()
{
    int n{};                // scalaire => initialisation à zéro, la valeur est 0
    assert(n == 0);
    double f = double();    // scalaire => initialisation à zéro, la valeur est 0.0
    assert(f == 0.0);
    int* a = new int[10](); // tableau => initialisation par valeur de chaque élément
    assert(a[9] == 0);      //          la valeur de chaque élément est 0
    T1 t1{};                // classe avec constructeur par défaut implicite =>
    assert(t1.mem1 == 0);   //     t1.mem1 est initialisé à zéro, la valeur est 0
    assert(t1.mem2 == "");  //     t1.mem2 est initialisé par défaut, la valeur est ""
//  T2 t2{};                // erreur : classe sans constructeur par défaut
    T3 t3{};                // classe avec constructeur par défaut fourni par l'utilisateur =>
    std::cout << t3.mem1;   //     t3.mem1 est initialisé par défaut à une valeur indéterminée
    assert(t3.mem2 == "");  //     t3.mem2 est initialisé par défaut, la valeur est ""
    std::vector<int> v(3);  // initialisation par valeur de chaque élément
    assert(v[2] == 0);      // la valeur de chaque élément est 0
    std::cout << '\n';
    delete[] a;
}

42

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi

• constructeur par défaut
• explicit
• initialisation d'agrégat
• initialisation par liste