Datasets:
Kant1
/
French_Wikibooks_articles

Dataset card Data Studio Files Community
1
text
stringlengths
0
211k
return 0;
Pointeurs vers structures.
Il est (bien entendu) possible de déclarer des variables de type pointeur vers structure :
struct ma_struct * ma_variable;
Comme pour tout pointeur, on doit allouer de la mémoire pour la variable avant de l'utiliser :
ma_variable = malloc( sizeof(struct ma_struct) );
L'accès aux champs peut se faire comme pour une variable de type structure « normale » :
(* ma_variable).champ
Ce cas de figure est en fait tellement fréquent qu'il existe un raccourci pour l'accès aux champs d'un pointeur vers structure :
ma_variable->champ
Unions.
Une union et un enregistrement se déclarent de manière identique :
union type_union
type1 champ1;
type2 champ2;
typeN champN;
/* Déclaration de variables */
union type_union var1, var2, /* ... */ varM;
Toutefois, à la différence d'un enregistrement, les N champs d'une instance de cette union occupent le même emplacement en mémoire. Modifier l'un des champ modifie donc tous les champs de l'union. Typiquement, une union s'utilise lorsqu'un enregistrement peut occuper plusieurs fonctions bien distinctes et que chaque fonction ne requiert pas l'utilisation de tous les champs.
Voici un exemple ultra classique d'utilisation des unions, qui provient en fait de la gestion des événements du système X-Window, très répandu sur les systèmes Unix :
union _XEvent
int type;
XAnyEvent xany;
XKeyEvent xkey;
XButtonEvent xbutton;
XMotionEvent xmotion;
XCrossingEvent xcrossing;
XFocusChangeEvent xfocus;
XExposeEvent xexpose;
XErrorEvent xerror;
XKeymapEvent xkeymap;
long pad[24];
La déclaration a juste été un peu raccourcie pour rester lisible. Les types codice_29 de l'union sont en fait des structures contenant des champs spécifiques au message. Par exemple, si codice_27 vaut codice_31, seules les valeurs du champ codice_32 seront significatives. Parmi ces champs, il y a codice_33 qui permet de savoir quel bouton de la souris à été pressé :
XEvent ev;
XNextEvent(display, &ev);
switch (ev.type) {
case ButtonPress:
printf("Le bouton %d a été pressé.\n", ev.xbutton.button);
break;
default:
printf("Message type %d\n", ev.type);
En offrant une souplesse nécessaire à la manipulation de l'objet, la gestion de la mémoire en C peut aider à réduire les erreurs de programmation lié à la structure de la mémoire (erreur de segmentation/segfault/"Argh!!!"):
struct s1 {
char *string;
} s1;
struct s2 {
char *string;
size_t len;
int ______;
int setnull;
} s2;
union str {
struct s2 s_;
struct s1 _s;
}str;
typedef void * STR_s1;
typedef void * STR_s2;
STR_s2
string_analyse(STR_s1 *s)
static union str us, init_us = ;
memcpy((void *)&us, (void *)&init_us, sizeof(union str));
if (!((struct s1 *)s)->string)
return &us._s;
us.s_.len = strlen(((struct s1 *)s)->string);
if (!us.s_.len)
us.s_.setnull = 1;
return &us._s;
us.s_.string = ((struct s1 *)s)->string;
return &us.s_;
int main(void)
struct s1 s = {NULL}, s_ = {"salut"}, s__ = {""};
void *p;
p = string_analyse((void *)&s);
printf("null? %s,%lu,%i\n",
((struct s2 *)p)->string, ((struct s2 *)p)->len, ((struct s2 *)p)->setnull);
p = string_analyse((void *)&s_);
printf("null? %s,%lu,%i\n",
((struct s2 *)p)->string, ((struct s2 *)p)->len, ((struct s2 *)p)->setnull);
p = string_analyse((void *)&s__);
printf("null? %s,%lu,%i\n",
((struct s2 *)p)->string, ((struct s2 *)p)->len, ((struct s2 *)p)->setnull);
printf("Réalisé en toute sécurité...\n"
"Même pour un petit vaisseau serial killer du monde d'en haut.\n");
return 0;
Tout en permettant l'optimisation:
struct s1{
size_t len;
char *str;
} s1;
union s {
struct s1 dbl[2];
void *perform[5];
struct s1 simple;
<br>
ce qui signifie que:
int main(void)
const char *end[2] = {", ", "\n"};
union s init = }, us;
void *p;
int s1s = sizeof(struct s1);