Discussion :

[yan]

Bonjour,

Si j'ai bien compris, on peux maintenant initialiser tous les membres d'une structure à 0 en utilisant des accolades vide

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
Foo bar;
bar = {};

Seulement ce n'est pas ce qui se passe dans ce code sous visual 2013

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
struct A
{
    unsigned char val;
};
 
 
struct B : public A
{
};
 
struct C
{
    A a;
};
 
 
int main (int argc, char* argv[])
{
    B b;
    C c;
 
    b.val = 1;
    b = {};//val = 204 <= pourquoi???
 
    c.a.val = 1;
    c = {};//a.val = 0 <= OK
 
    return 0;
}

Sur la struct B, cela initialise toute la mémoire par des valeurs 8bits de valeurs 204.

Je ne comprend pas pourquoi, la structure B ne se met pas à zéro.

Si quelqu'un as une idée.

merci
Yan

[Bousk]

Tu as compris et vu ça où ?
La seule syntaxe que je connais c'est char c[12] = {0}; qui est équivalent à faire un memset à 0 sur la structure à sa création, mais ça ne marche qu'à la déclaration il me semble.
Et qu'on peut appeler le constructeur avec des {} depuis C++14 (je crois).

[Iradrille]

Seulement ce n'est pas ce qui se passe dans ce code sous visual 2013

Marrant, ça met bien le contenu à 0 sous VS2015 (mais j'avoue que la syntaxe m'étonne).

[yan]

En principe c'est un ajout de C++14 mais je n'ai pas trouvé de super info dessus. Juste dans quelques réponses de stackowerflow

Dans mon cas, ce que j'ai compris
* struct A et C sont des POD et tous les membres sont mise à zéro (constructeur par défaut d'une struct POD).
* struct B n'est pas un POD à cause de l'héritage =>l'init pas défaut ne met pas les membre à 0. Si j'ajoute un constructeur par défaut, la struct prend les valeurs fournie par ce constructeur.

Pour le 204, c'est en faite 0xCC en hexa qui est un magic number de visual studio :
CCCCCCCC : Used by Microsoft's C++ debugging runtime library and many DOS environments to mark uninitialized stack memory. CC resembles the opcode of the INT 3 debug breakpoint interrupt on x86 processors.

Ce qui m'étonne est que l'héritage rend la struct B non POD.

yan

[bacelar]

VS2013 n'est pas full compliant C++14, VS2015 non plus je crois, mais plus que VS2013.
Le mode DEBUG peut peut-être jouer aussi.

[yan]

VS2013 n'est pas full compliant C++14, VS2015 non plus je crois, mais plus que VS2013.
Le mode DEBUG peut peut-être jouer aussi.

La valeur 0xCC est bien seulement en debug.

[Bousk]

Mué, le sujet que tu montres de SO date de 2009, donc pour la fonctionnalité de C++14 j'ai des doutes.
Ca ressemble juste à l'initialisation des struct en C via ={0}; raccourci. J'ai pour habitude de mettre le 0 mais il est sûrement superflu.

[yan]

Mué, le sujet que tu montres de SO date de 2009, donc pour la fonctionnalité de C++14 j'ai des doutes.

J'avoue je n'ai pas fait attention au date. Je suis parfois perdu entre les normes. Surtout que visual s'est souvent permis quelque liberté par rapport à la norme. Ce qui normalement n'est plus le cas aujorud'hui.

Ca ressemble juste à l'initialisation des struct en C via ={0}; raccourci. J'ai pour habitude de mettre le 0 mais il est sûrement superflu.

En C le 0 est obligatoire il me semble. Mais l'idée c'est bien cela. Et c'est justement le cas de la struct B qui m'as posé problème. Je pensais que cela devait initialiser toutes la structure à 0. D'où le poste de départ.

[Ehonn]

Au sujet de l'initialisation uniforme en C++11 : http://www.stroustrup.com/C++11FAQ.html#uniform-init http://www.stroustrup.com/C++11FAQ.html#init-list

[stendhal666]

EDIT: à la réflexion, je suis en retard d'un standard, sorry

Je crois que tu confonds deux choses:

- depuis C++11, un type de base comme int, char, etc. est initialisé à 0 quand il est initialisé par une paire d'accolades vide (http://en.cppreference.com/w/cpp/lan...initialization)
- si un type utilisateur est initialisé avec une accolade vide, ce sont les règles de l'initialisation par défaut (http://en.cppreference.com/w/cpp/lan...initialization). Dans ce cas-là, selon la nature du type initialisé, un constructeur est appelé ou bien, s'il s'agit d'un type POD, comme par exemple une structure composée uniquement de types de base et sans constructeur d'aucune sorte, ses membres sont initialisés à une valeur indéterminée: je pense que c'est le cas pour ta structure.

[Iradrille]

- depuis C++11, un type de base comme int, char, etc. est initialisé à 0 quand il est initialisé par une paire d'accolades vide (http://en.cppreference.com/w/cpp/lan...initialization)

C'est bien ce cas là: type de base ou ctor par défaut

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
struct T1
{
    int mem1;
    std::string mem2;
}; // implicit default constructor
 
int main()
{
    T1 t1 {};               // class with implicit default constructor
                            //     t1.mem1 is zero-initialized
                            //     t1.mem2 is default-initialized
}

Du coup VS2013 ne respecte pas cette règle en cas d'héritage, mais VS 2015 la respecte.

[yan]

Dans ce cas-là, selon la nature du type initialisé, un constructeur est appelé ou bien, s'il s'agit d'un type POD, comme par exemple une structure composée uniquement de types de base et sans constructeur d'aucune sorte, ses membres sont initialisés à une valeur indéterminée: je pense que c'est le cas pour ta structure.

*Pour une struct POD, le compilateur as un constructeur par defaut qui met tout à 0 (depuis standard ??
* pour une stuct non POD, le constructeur par défaut ne fait rien.

Et c'est surement ce qui se passe pour ma struct B. Elle n'est pas POD à cause de l'héritage et donc le constructeur par défaut ne fait rien.

Je met en résolu car je pense que j'ai ma réponse.
Merci à tous.

[yan]

Du coup VS2013 ne respecte pas cette règle en cas d'héritage, mais VS 2015 la respecte.

Il n'y as pas de problème sur la struct que tu montre. J'ai seulement un problème dans la struct B qui as un comportement différent à cause de l'héritage.

[Iradrille]

Il n'y as pas de problème sur la struct que tu montre. J'ai seulement un problème dans la struct B qui as un comportement différent à cause de l'héritage.

Elle n'est pas POD à cause de l'héritage et donc le constructeur par défaut ne fait rien.

Justement, nulle part ils ne parlent de POD

Since C++11, value-initializing a class without a user-provided constructor, which has a member of a class type with a user-provided constructor zeroes out the member before calling its constructor:

.Je pense que c'est simplement un problème avec VS 2013 qui ne respecte pas la norme en cas d'héritage.

[yan]

Je pense que c'est simplement un problème avec VS 2013 qui ne respecte pas la norme en cas d'héritage.

Ok merci

[Ehonn]

*Pour une struct POD, le compilateur as un constructeur par defaut qui met tout à 0 (depuis standard ??

Je suis pas sur de comprendre la phrase, mais dans :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
struct test_t
{
    int i;
};

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

test_t t; // t.i n'est pas forcément égal à 0

Contrairement à :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
struct test_t
{
    int i;
 
    test_t() : i() { }
};

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

test_t t; // t.i est forcément égal à 0

[yan]

Je suis pas sur de comprendre la phrase, mais dans :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
struct test_t
{
    int i;
};

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

test_t t; // t.i n'est pas forcément égal à 0

par ce que dans ce cas il n'y as pas d'appel au constructeur implicite qui met à zero la structure :/.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
test_t t; // t.i n'est pas forcément égal à 0
t = test_t();// on copie dans t une structure initialiser avec le constructeur implicite.
 
 
class foo
{
    test_t t;
public :
    foo()
    : t() //appel du constructeur implicite généré par le compilateur et qui met tout à zéro
{
 
}

Les types POD (peut être les types non POD aussi?), sans constructeur de définie, ont un constructeur implicite qui l'initialise à zéro mais qu'il faut appeler explicitement. Sinon c'est le constructeur définie qui est appelé.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
struct test_t
{
    int t;
   test_t()//constructeur
   :t()//appel le constructeur implicite qui met à zéro t
   {}
 
};
 
test_t t; //appel le constructeur définie => i = 0

[yan]

Je pense que c'est simplement un problème avec VS 2013 qui ne respecte pas la norme en cas d'héritage.

J'ai trouve ceci : http://en.cppreference.com/w/cpp/lan...initialization
Ca semble dire plutôt dire que ce qui se passe sous visual 2013 est normale....