Tableau de caractères dans une struct – assignation incompatible?

J’ai essayé de comprendre ce qu’est vraiment une structure et de poser un problème, alors j’ai vraiment 2 questions:

1) Qu’est-ce qui est enregistré dans ‘sara’? Est-ce un pointeur sur le premier élément de la structure?

2) La question la plus intéressante: pourquoi ne comstack-t-il pas? GCC dit “test.c: 10: erreur: types incompatibles dans une assignation” et je ne comprends pas pourquoi …

#include  struct name { char first[20]; char last[20]; }; int main() { struct name sara; sara.first = "Sara"; sara.last = "Black"; printf("struct direct: %x\n",sara); printf("struct deref: %x\t%s\n", *sara, *sara); } 

Merci de votre aide!

Cela n’a rien à voir avec les structures – les tableaux en C ne sont pas assignables:

 char a[20]; a = "foo"; // error 

vous devez utiliser strcpy:

 strcpy( a, "foo" ); 

ou dans votre code:

 strcpy( sara.first, "Sara" ); 

Ou vous pouvez simplement utiliser l’allocation dynamic, par exemple:

 struct name { char *first; char *last; }; struct name sara; sara.first = "Sara"; sara.last = "Black"; printf("first: %s, last: %s\n", sara.first, sara.last); 

utilisez strncpy pour vous assurer de ne pas avoir de dépassement de tampon.

 char name[]= "whatever_you_want"; strncpy( sara.first, name, sizeof(sara.first)-1 ); sara.first[sizeof(sara.first)-1] = 0; 

Vous pouvez également l’initialiser comme ceci:

 struct name sara = { "Sara", "Black" }; 

Étant donné que (dans un cas particulier), vous êtes autorisé à initialiser des tableaux de caractères à partir de constantes de chaîne.

Maintenant, quant à ce qu’est en réalité une structure – c’est un type composé composé d’autres valeurs. En mémoire, sara ressemble à un bloc de 20 valeurs de caractère consécutives (auquel on peut se référer à l’aide de sara.first , suivi d’au moins 0 octets de remplissage, suivi d’un autre bloc de 20 valeurs de caractère consécutives (à l’aide de sara.last ). Toutes les autres instances du type struct name sont présentées de la même manière.

Dans ce cas, il est très peu probable qu’il y ait un remplissage, donc un struct name est juste un bloc de 40 caractères, pour lequel vous avez un nom pour les 20 premiers et les 20 derniers.

Vous pouvez connaître la taille d’un bloc de mémoire qu’un struct name prend à l’aide de sizeof(struct name) , ainsi que l’emplacement de chaque membre de la structure dans ce bloc de mémoire en utilisant offsetof(struct name, first) et offsetof(struct name, last) .

sara est la structure elle-même, pas un pointeur (c’est-à-dire la variable représentant l’emplacement sur la stack où les données de structure réelles sont stockées). Par conséquent, *sara n’a pas de sens et ne comstack pas.

La structure Sara est un bloc de mémoire contenant les variables à l’intérieur. Il n’y a presque pas de différence entre une déclaration classique:

 char first[20]; int age; 

et une structure:

 struct Person{ char first[20]; int age; }; 

Dans les deux cas, vous allouez simplement de la mémoire pour stocker des variables, et dans les deux cas, 20 + 4 octets seront réservés. Dans votre cas, Sara n’est qu’un bloc mémoire de 2×20 octets.

La seule différence est qu’avec une structure, la mémoire est allouée sous la forme d’un seul bloc. Par conséquent, si vous prenez l’adresse de départ de Sara et sautez 20 octets, vous trouverez la “dernière” variable. Cela peut être utile parfois.

consultez http://publications.gbdirect.co.uk/c_book/chapter6/structures.html pour plus :).

Vous pouvez utiliser strcpy pour le remplir. Vous pouvez également l’initialiser à partir d’une autre structure.

 #include  #include  #include  struct name { char first[20]; char last[20]; }; int main() { struct name sara; struct name other; strcpy(sara.first,"Sara"); strcpy(sara.last, "Black"); other = sara; printf("struct: %s\t%s\n", sara.first, sara.last); printf("other struct: %s\t%s\n", other.first, other.last); }