C++ struct initialisation de tableau

C'est ok:

int vec_1[3] = {1,2,3};

quel est donc le problème avec

struct arrays{
  int x[3];
  int y[3];
  int z[3];
};
arrays vec_2;
vec_2.x = {1,2,3};

qui donne
erreur: impossible de convertir de ‘<corset-joint une liste d'initialiseur>’ int’ dans l'affectation

J'ai lu beaucoup de posts sur cette erreur, mais il n'est toujours pas clair où est le problème.

Parce qu'il a déjà été créé.
Le second n'est pas valide en C++. Essayez ceci: int vec_1[3]; suivie par vec_1 = {1, 2, 3}; Cela aussi ne compile pas pour la même raison.

OriginalL'auteur brunetto | 2012-03-22

arrays braces c++initialization struct

5

La première est l'initialisation. La deuxième est une tentative de cession, mais les tableaux ne sont pas cessibles.

Vous pourriez faire quelque chose comme:
```
arrays vec_2 = {{1,2,3}, {3,4,5}, {4,5,6}};
```
Si vous ne voulez initialiser vec_2.x, alors vous pouvez simplement laisser le reste de la initialiseurs:
```
 arrays vec_2 = {1,2,3};
```
Dans ce cas, le reste de vec_2 sera initialisé à contenir des zéros.

Alors que vous devez inclure au moins un jeu d'accolades autour de la initialiseurs, vous n'avez pas à inclure le "intérieure" si vous ne voulez pas. Y compris entre eux peuvent vous donner un peu plus de souplesse. Par exemple, si vous souhaitez initialiser le premier des deux éléments dans la vec_2.x et le premier vec_2.y, vous pouvez utiliser:
```
arrays vec_2 = {{1,2}, {3}};
```
Dans ce cas, vous aurez vec_2 définir comme si vous aviez utilisé {1, 2, 0, 3, 0, 0, 0, 0, 0}; que l'initialiseur.

Je me serais attendu à C++11 pour permettre x={1,2,3}, mais il n'a pas ([expr.cul] 5.17/9). Encore une autre raison de préférer std::array. Raw tableaux ont trop peu de design.

OriginalL'auteur Jerry Coffin

C'est d'affectation, pas d'initialisation:

arrays vec_2;
vec_2.x = {1,2,3};

Utiliser, ce qui est équivalent à ce que vous tentiez:

arrays vec_2 = { {1, 2, 3 } };

Si vous souhaitez fournir des valeurs pour y et z aussi:

arrays vec_2 = { {1,2,3}, //x
                 {4,5,6}, //y
                 {7,8,9}  //z
               };

OriginalL'auteur hmjd

2
```
int vec_1[3] = {1,2,3};
```
En dépit de ce à quoi il ressemble, ce n'est pas affectation, c'est (effectivement) un appel de constructeur. Il construit un tableau de int initialisé à ces valeurs.
```
arrays vec_2;
```
Ceci construit une structure (struct), et chacun des membre des tableaux avec des valeurs par défaut.
```
vec_2.x = {1,2,3};
```
Vous ne pouvez pas attribuer les tableaux, et ce membre a déjà été construit. La solution de contournement est en tant que tel:
```
arrays vec_2 = { {1, 2, 3} };
```
qui est la même chose que
```
arrays vec_2 = { {1, 2, 3}, {0, 0, 0}, {0, 0, 0} };
```
OriginalL'auteur Mooing Duck
2
```
arrays vec_2;
vec_2.x = {1,2,3};
```
Que le message d'erreur dit, la deuxième ligne est affectation, pas initialisation. Ils sont deux choses différentes.

Vous avez besoin pour ce faire:
```
arrays vec_2 = {
      {1,2,3}, //initializes x 
      {5,6,7}, //initializes y
      {7,8,9}, //initializes z 
};
```
Noter que , est autorisée après la dernière intérieure-brace! (j'.e {7,8,9}, <-- autorisé). Une telle virgule est généralement utile pour le code généré: vous pouvez ajouter une autre ligne, sans se soucier de la virgule, ni ne vous devez tenir compte de chaque cas particulier de la dernière ligne.

OriginalL'auteur Nawaz
1

Dans le premier exemple, vous êtes intializing le vecteur lorsque vous déclarez.

Dans le deuxième exemple, vous êtes intializing deux fois (illégal), une fois lorsque vous déclarez le arrays struct, puis de nouveau lorsque vous dites vec_2.x = {1,2,3}

OriginalL'auteur Pepe

Vous devez vous connecter pour publier un commentaire.