Question sur la déclaration / l’affectation d’un tableau C simple

Dans les langages de niveau supérieur, je pourrais utiliser quelque chose de similaire à cet exemple en C et tout irait bien. Cependant, lorsque je comstack cet exemple C, il se plaint amèrement. Comment puis-je affecter de nouveaux tableaux au tableau que j’ai déclaré?

int values[3]; if(1) values = {1,2,3}; printf("%i", values[0]); 

Merci.

vous pouvez déclarer un tableau statique avec des données à initialiser:

 static int initvalues[3] = {1,2,3}; … if(1) memmove(values,initvalues,sizeof(values)); 

Vous ne pouvez effectuer plusieurs affectations du tableau que lorsque vous déclarez le tableau:

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

Après la déclaration, vous devez atsortingbuer chaque valeur individuellement, c.-à-d.

 if (1) { values[0] = 1; values[1] = 2; values[2] = 3; } 

Vous pouvez également utiliser une boucle, en fonction des valeurs que vous souhaitez utiliser.

 if (1) { for (i = 0 ; i < 3 ; i++) { values[i] = i+1; } } 

En C99, en utilisant des littéraux composés , vous pourriez faire:

 memcpy(values, (int[3]){1, 2, 3}, sizeof(int[3])); 

ou

 int* values = (int[3]){1, 2, 3}; 
  //comstack time initialization int values[3] = {1,2,3}; //run time assignment value[0] = 1; value[1] = 2; value[2] = 3; 
 #include #include #include int *setarray(int *ar,char *str) { int offset,n,i=0; while (sscanf(str, " %d%n", &n, &offset)==1) { ar[i]=n; str+=offset; i+=1; } return ar; } int *setarray2(int *ar,int num,...) { va_list valist; int i; va_start(valist, num); for (i = 0; i < num; i++) ar[i] = va_arg(valist, int); va_end(valist); return ar; } int main() { int *size=malloc(3*sizeof(int*)),i; setarray(size,"1 2 3"); for(i=0;i<3;i++) printf("%d\n",size[i]); setarray2(size,3 ,4,5,6); for(i=0;i<3;i++) printf("%d\n",size[i]); return 0; } 

Il est également possible de masquer la mémoire en utilisant la copie de bloc de struct du compilateur. Cela rend le code laid à cause de tous les .i et i: mais peut-être que cela résoudra votre problème spécifique.

 typedef struct { int i[3]; } inta; int main() { inta d = {i:{1, 2, 3}}; if (1) d = (inta){i:{4, 5, 6}}; printf("%d %d %d\n", di[0], di[1], di[2]); return 0; } 

Cela fonctionne et optimise mieux sous gcc avec -O3 (le compilateur supprime complètement le code), alors que la mémoire oblige la mémoire à être copiée dans tous les cas.

 template  struct inner { Array x; }; template  void assign(Array& lhs, const Array& rhs) { inner& l( (inner&)(lhs)); const inner& r( (inner&)(rhs)); l = r; } int main() { int x[100]; int y[100]; assign(x, y); } 

Il y a aussi ça … 🙂

 char S[16]=""; strncpy(S,"Zoodlewurdle...",sizeof(S)-1); 

Testez ce qui se passe si vous déclarez S [8] ou S [32], pour voir pourquoi ceci est si efficace.

J’ai écrit mes propres fonctions de chaîne basées sur la logique de strlcpy d’OpenBSD, visant à garantir qu’un octet de terminaison DOIT exister en cas de dépassement, et strncpy standard ne le fera pas. Vous devez donc surveiller de près son utilisation.

La méthode ci-dessus est efficace car ="" lors de la déclaration garantit 0 octet, et sizeof(S)-1 garantit que si vous dépassez la chaîne citée passée à strncpy, vous obtenez une troncature et aucune violation du est sûr contre le débordement maintenant, et sur l’access à la chaîne plus tard. J’ai visé ceci à ANSI C, donc ça devrait être en sécurité n’importe où.

Je posterais cela comme un commentaire, mais je n’ai pas assez de réputation. Une autre façon (peut-être malpropre) d’initialiser un tableau est de l’envelopper dans une structure.

 #include  struct wrapper { int array[3]; }; int main(){ struct wrapper a; struct wrapper b = {{1, 2, 3}}; a = b; printf("%i %i %i", a.array[0], a.array[1], a.array[2]); return 0; }