Que signifient les phrases suivantes en C ++: initialisation à zéro, par défaut et par valeur?

Question

Que signifient les phrases suivantes en C ++:

• initialisation zéro,

• initialisation par défaut et

• initialisation de valeur

Que devrait savoir un développeur C ++ à leur sujet?

Answer 1

Il convient de noter que l’initialisation de la valeur est une nouveauté dans la norme C ++ 2003; elle n’existe pas dans la norme originale de 1998 (je pense que c’est peut-être la seule différence qui dépasse la clarification). Voir Kirill La réponse de V. Lyadvinsky pour les définitions directement de la norme.

Voir cette réponse précédente sur le comportement de opérateur new pour plus de détails sur les comportements différents de ces types d'initialisation et quand ils entrent en jeu (et lorsqu'ils diffèrent de c ++ 98 à C + +03):

• Les parenthèses après le nom du type font-elles la différence avec new?

Le point principal de la réponse est:

  

Parfois, la mémoire renvoyée par le nouvel opérateur est initialisée et parfois non, selon que le type que vous créez est un POD ou s'il s'agit d'une classe contenant des membres POD et utilisant un compilateur. constructeur par défaut généré.

     

  
• En C ++ 1998, il existe 2 types d'initialisation: zéro et par défaut
  
• En C ++ 2003, un troisième type d'initialisation, l'initialisation de valeur, a été ajouté.
  

Pour dire le moins, c'est assez complexe et lorsque les différentes méthodes de frappe sont subtiles.

Une chose à savoir, c’est que MSVC respecte les règles C ++ 98, même dans VS 2008 (VC 9 ou cl.exe version 15.x).

L'extrait suivant montre que MSVC et Digital Mars suivent les règles C ++ 98, tandis que GCC 3.4.5 et Comeau suivent les règles C ++ 03:

#include <stdio.h>
#include <string.h>
#include <new>

struct A { int m; }; // POD
struct B { ~B(); int m; }; // non-POD, compiler generated default ctor
struct C { C() : m() {}; ~C(); int m; }; // non-POD, default-initialising m

int main()
{
    char buf[sizeof(B)];
    memset( buf, 0x5a, sizeof( buf));

    // use placement new on the memset'ed buffer to make sure 
    //  if we see a zero result it's due to an explicit 
    //  value initialization
    B* pB = new(buf) B();   //C++98 rules - pB->m is uninitialized
                            //C++03 rules - pB->m is set to 0
    printf( "m  is %d\n", pB->m);
    return 0;
}

Answer 2

C ++ 03 Standard 8.5 / 5:

  

Pour initialiser à zéro , un objet de type T signifie:
  - si T est un type scalaire (3.9), l'objet est défini sur la valeur 0 (zéro) convertie en T;
  - si T est un type de classe non-union, chaque membre de données non statique et chaque sous-objet de classe de base est initialisé à zéro;
  - si T est un type d’union, le premier membre de données nommé de l’objet est initialisé à zéro;
  - si T est un type de tableau, chaque élément est initialisé à zéro;
  - si T est un type de référence, aucune initialisation n'est effectuée.

     

Pour initialiser par défaut , un objet de type T signifie:
  - si T est un type de classe autre que POD (clause 9), le constructeur par défaut de T est appelé (et l'initialisation est mal formée si T n'a pas de constructeur par défaut accessible);
  - si T est un type de tableau, chaque élément est initialisé par défaut;
  - sinon l'objet est initialisé à zéro.

     

Pour initialiser une valeur , un objet de type T signifie:
  - si T est un type de classe (clause 9) avec un constructeur déclaré par l'utilisateur (12.1), le constructeur par défaut de T est appelé (et l'initialisation est mal formée si T n'a pas de constructeur par défaut accessible);
  - si T est un type de classe non-union sans constructeur déclaré par l'utilisateur, chaque membre de données non statique et chaque composant de classe de base de T sont initialisés par valeur;
  - si T est un type de tableau, chaque élément est initialisé en valeur;
  - sinon l'objet est initialisé à zéro

     

Un programme qui appelle une initialisation par défaut ou une initialisation de valeur d'une entité de type référence est mal formé. Si T est un type qualifié cv, la version non qualifiée cv est utilisée pour ces définitions d'initialisation zéro, d'initialisation par défaut et d'initialisation de valeur.