Attribuer plusieurs valeurs à un tableau en C

Est-il un moyen de le faire dans une forme condensée?

GLfloat coordinates[8];
...
coordinates[0] = 1.0f;
coordinates[1] = 0.0f;
coordinates[2] = 1.0f;
coordinates[3] = 1.0f;
coordinates[4] = 0.0f;
coordinates[5] = 1.0f;
coordinates[6] = 0.0f;
coordinates[7] = 0.0f;
return coordinates;

Quelque chose comme coordinates = {1.0f, ...};?

Êtes-vous de retourner un pointeur sur une variable locale, là? Certaines des choses que les gens ont dit dans les réponses/commentaires ci-dessous supposent que les variables impliquées sont automatiques, ou qu'ils ne le sont pas. Pourrait aider si vous spécifiez.
Une fois que la structure est initialisé, il n'y a pas un moyen facile de masse affecter des membres (autres que de faire une copie d'une autre structure avec memcpy). Je me retrouve souvent désireux j'ai eu cette fonction.
Je pense que votre réponse originale à cette question est le meilleur -- c'est de l'intuition, bien qu'un peu verbeux, mais ce n'est pas un sujet de préoccupation pour les compilateurs modernes.

InformationsquelleAutor UnstableFractal | 2010-08-20

arrays c declaration initialization

26

Si vous avez vraiment à attribuer valeurs (par opposition à initialiser), vous pouvez le faire comme ceci:
```
 GLfloat coordinates[8]; 
 static const GLfloat coordinates_defaults[8] = {1.0f, 0.0f, 1.0f ....};
 ... 
 memcpy(coordinates, coordinates_defaults, sizeof(coordinates_defaults));

 return coordinates; 
```
- C'est une bonne idée, je vais peut-être faire de cette façon.
- Mieux même, de la rendre "static const" et les compilateurs peuvent optimiser la variable à droite du code.
- Bon point!
- Lynx: ne pas la plupart des compilateurs être assez intelligents pour le faire de toute façon? Oh bien. Une bonne pratique pour être explicite, je suppose.
- Cooper: pas si elle est globale (qui peut être modifié dans le code, le compilateur ne peut pas voir). Vous ne pouvez pas vraiment dire à partir de ces extraits de code que les "..." élude le début d'une fonction.
- Bon appel. Merci pour la clarification.
InformationsquelleAutor James Curran
10

Old school:
```
GLfloat coordinates[8];
...

GLfloat *p = coordinates;
*p++ = 1.0f; *p++ = 0.0f; *p++ = 1.0f; *p++ = 1.0f;
*p++ = 0.0f; *p++ = 1.0f; *p++ = 0.0f; *p++ = 0.0f;

return coordinates;
```
- Élégant, je vous donne, mais la gestion d'une partie raisonnable ensemble de données d'initialisation (avec la nécessité éventuelle de les ajuster) sera lourd. Je préfère certains de la syntaxe, où seules les données (et peut-être des délimiteurs pour des raisons de visibilité) suffirait. En outre, il est de l'arithmétique des pointeurs. MISRA deviendrais folle à ce sujet.
InformationsquelleAutor Pavel Minaev
10

Il y a un truc pour envelopper le tableau dans une structure (qui peut être initialisé après la déclaration).

ie.
```
struct foo {
  GLfloat arr[10];
};
...
struct foo foo;
foo = (struct foo) { .arr = {1.0, ... } };
```
- Oh, vous n'avez pas besoin de cela, tout simplement initialisation ferait. Mépris de ma réponse.
- Vous pouvez cliquer sur "supprimer" en bas à gauche de votre post si vous le souhaitez. =P
- Oh, eh bien... peut-être que quelqu'un le trouve utile 🙂
- J'ai trouvé utile, quatre ans plus tard 🙂
InformationsquelleAutor domen
3

Exactement, vous avez presque eu:
```
GLfloat coordinates[8] = {1.0f, ..., 0.0f};
```
- Que faire si je l'ai fait et à réaffecter après?
- Cette syntaxe s'applique uniquement aux déclarations
- C'est mauvais.. Est-il d'autres moyen de le simplifier? 🙂
InformationsquelleAutor Felix Kling
3

Vous pouvez utiliser:
```
GLfloat coordinates[8] = {1.0f, ..., 0.0f};
```
mais c'est au moment de la compilation d'initialisation - vous ne pouvez pas utiliser cette méthode dans la norme actuelle pour ré-initialiser (bien que je pense qu'il y a des façons de le faire dans la norme à venir, qui ne peuvent pas immédiatement vous aider).

Les deux autres moyens qui viennent à l'esprit sont à blat le contenu, s'ils sont fixes:
```
GLfloat base_coordinates[8] = {1.0f, ..., 0.0f};
GLfloat coordinates[8];
:
memcpy (coordinates, base_coordinates, sizeof (coordinates));
```
ou de fournir une fonction qui ressemble à votre code d'initialisation de toute façon:
```
void setCoords (float *p0, float p1, ..., float p8) {
    p0[0] = p1; p0[1] = p2; p0[2] = p3; p0[3] = p4;
    p0[4] = p5; p0[5] = p6; p0[6] = p7; p0[7] = p8;
}
:
setCoords (coordinates, 1.0f, ..., 0.0f);
```
en gardant à l'esprit ces points de suspension (...) sont des espaces réservés, et non pas les choses à la lettre d'insérer dans le code.

InformationsquelleAutor paxdiablo

Si vous faites ces mêmes affectations beaucoup dans votre programme et que vous voulez un raccourci, la solution la plus simple pourrait être de simplement ajouter une fonction

static inline void set_coordinates(
        GLfloat coordinates[static 8],
        GLfloat c0, GLfloat c1, GLfloat c2, GLfloat c3,
        GLfloat c4, GLfloat c5, GLfloat c6, GLfloat c7)
{
    coordinates[0] = c0;
    coordinates[1] = c1;
    coordinates[2] = c2;
    coordinates[3] = c3;
    coordinates[4] = c4;
    coordinates[5] = c5;
    coordinates[6] = c6;
    coordinates[7] = c7;
}

et puis il suffit d'appeler

GLfloat coordinates[8];
//...
set_coordinates(coordinates, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f);

InformationsquelleAutor dpi

-1

typedef struct{
  char array[4];
}my_array;

my_array array = { .array = {1,1,1,1} }; //initialisation

void assign(my_array a)
{
  array.array[0] = a.array[0];
  array.array[1] = a.array[1];
  array.array[2] = a.array[2];
  array.array[3] = a.array[3]; 
}

char num = 5;
char ber = 6;

int main(void)
{
  printf("%d\n", array.array[0]);
//...

  //this works even after initialisation
  assign((my_array){ .array = {num,ber,num,ber} });

  printf("%d\n", array.array[0]);
//....
  return 0;
}

InformationsquelleAutor Marek

Vous devez vous connecter pour publier un commentaire.