Type de variable

**dafpp** · 20/12/2011, 12h14

Bonjour,
je voudrai comprendre un truc, le type est lié à l'adresse de la variable, ou c'est autrement ?
par exemple

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
int main ()
{
int a;
g (&a);
}
 
void g (double * b)
{
double * c = malloc(sizeof(b));
}

qu'est ce que j'aurai comme retour de malloc (int, double ?) ? est ce que le type de retour est vraiment important avec malloc ? qu'est ce que ça changeait si j'avais fait g(a) ?

je comprends peut-être mal un truc, et j'aimerai le comprendre correctement.
car je fais un programme avec pleins de structures différentes, mais qui ont des points communs (nom de variables - mais pas toutes), il n'y a pas d'héritage, donc je pensais utilisé des structures types, qui engloberait par exemple toutes les structures ayant comme paramètres 'data', et je voulais les utiliser exclusivement pour les allocation de mémoire ou de libération de mémoire, mais j'ai peur que ça cache des problèmes, et que je comprenne pas forcement ce qui va pas.

merci de m'aider.
j'ai dû mal à m'exprimer correctement, donc si vous n'avez pas compris, n'hésitez pas.

@ bientôt

**Thierry Chappuis** · 20/12/2011, 12h36

malloc() ne retourne ni un entier de type int, ni un entier de type double. Cette fonction retourne l'adresse d'un espace mémoire alloué dynamiquement dans lequel il est possible de placer la valeur d'une variable, éventuellement de type int ou de type double en fonction de la taille mémoire de l'espace alloué. Le type de la variable retournée par malloc() est un pointeur générique de type (void *) qui peut être converti, implicitement ou explicitement, en n'importe quel autre type de pointeur.

Dans ton exemple, malloc() alloue l'espace mémoire pour stocker une variable de type pointeur sur double et retourne l'adresse de cet espace mémoire. Ta variable c doit par conséquent avoir le type de pointeur sur un pointeur sur double, à savoir double **. Nous avons donc:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
int main(void)
{
    /* -tc- Si on suppose que a est de type double, et non int comme
        dans ton exemple */
    double a;
    /* -tc- On passage a la fonction g() l'adresse de la variable a, de type 
        pointeur sur double (double *) */
    g(&a);
}
 
/* -tc- La fonction g() prend en argument une variable de type pointeur sur 
   double  */
void g(double * b)
{
    /* -tc- malloc() retourne l'adresse d'un espace memoire alloue pour
        un pointeur sur double et retourne l'adresse de cet espace mémoire */
    double ** c = malloc(sizeof b);
    /* -tc- Toujours tester la validite de l'adresse retournee par malloc()
    if (c != NULL)
    {
        /* -tc- Eventuellement faire qqch avec c */
 
        /* -tc- Une fois qu'on quitte la fonction g(), la variable c est perdue,
            mais l'espace alloue n'est pas libere. Ne pas oublier de liberer l'espace
            alloue par malloc() avec free(). */
        free(c), c = NULL;
    }
}

Si c'est l'espace mémoire pour un flottant de type double que tu désires allouer, tu peux écrire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

double * c = malloc(sizeof *b);

Le reste du code reste identique. Ne perd pas de vue que si l'adresse stockée dans le pointeur c n'est pas retournée d'une manière ou d'une autre à la fonction appelante, l'adresse de cet espace mémoire est perdue alors que l'espace lui-même n'est pas libéré.

Avec mes meilleures salutations

Thierry

**Bktero** · 20/12/2011, 14h36

Petite question pour Thierry : la taille d'un objet de type "pointeur sur X" dépend-elle de la nature de X ?

**matafan** · 20/12/2011, 15h47

Je ne crois pas que la norme dise quoi que ce soit au sujet de la taille des pointeurs. En particulier, je pense qu'il est théoriquement possible que des pointeurs vers des données et des pointeurs vers du code ne fassent pas la même taille.

En pratique je ne pense pas qu'il existe des architectures où tous les types de pointeurs n'ont pas la même taille.

**dafpp** · 20/12/2011, 16h07

merci pour vos réponses, je vois un peu mieux les choses.

je vois comment je vais faire ce que je voulais faire

>et désolé pour l'oubli de balise 'code'

**Thierry Chappuis** · 20/12/2011, 16h27

Envoyé par Bktero

Petite question pour Thierry : la taille d'un objet de type "pointeur sur X" dépend-elle de la nature de X ?

A mon avis, c'est indéfini. Ce que dit la norme, c'est qu'un pointeur générique de type (void *) doit pouvoir être converti vers n'importe quel type de pointeur. Il semble qu'il soit possible de convertir un type pointeur vers un autre type pointeur, et retour, sans perte d'info si l'adresse contenue dans le pointeur satisfait les contraintes d'alignement du nouvel objet pointé. En cas de violation des contraintes d'alignement, le comportement semble indéfini. Cette question est discutée au §6.3.2.3 de n1256.

Avec mes meilleures salutations

Thierry

**dafpp** · 20/12/2011, 19h29

en faite je préfère reposer une question, histoire d'être sûr

si on alloue de la mémoire et que l'on cast pas, cela convertira automatiquement de void * (le retour d'adresse de malloc) au type de la variable qui reçoit l'allouement de mémoire ? donc si c'est oui, le type de la variable est lié á la variable, lors de l'execution, donc si on alloue de la mémoire avec une variable d'un autre type mais qui pointe vers l'autre d'un autre type, est ce que allouer de la mémoire sur cette dernière variable changera qqchose ?

--> surement que non, il n'y a que la taille du type qui compte, mais je veux être sûr, c'est que c'est sûrement pas forcement clair dans ma tête.

**Sve@r** · 20/12/2011, 19h44

Envoyé par dafpp

en faite je préfère reposer une question, histoire d'être sûr

si on alloue de la mémoire et que l'on cast pas, cela convertira automatiquement de void * (le retour d'adresse de malloc) au type de la variable qui reçoit l'allouement de mémoire ? donc si c'est oui, le type de la variable est lié á la variable, lors de l'execution, donc si on alloue de la mémoire avec une variable d'un autre type mais qui pointe vers l'autre d'un autre type, est ce que allouer de la mémoire sur cette dernière variable changera qqchose ?

Salut
C'est pas faux...

Envoyé par dafpp

c'est que c'est sûrement pas forcement clair dans ma tête.

Oui je vois ça.

Ce qu'il faut bien comprendre, c'est que pour le C, une adresse n'est qu'un nombre. A priori, rien ne t'interdit d'écrire

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
int x;
x=malloc(sizeof(double));   // Stocker l'adresse de la zone allouée dans un entier

Le problème vient de ce que tu en fais après. Parce que avoir une adresse d'une zone mémoire ne se justifie que si tu vas travailler avec la zone mémoire concernée. Et l'opérateur "utiliser le contenu" est l'étoile single. Donc si tu veux stocker pi à l'adresse allouée, la suite logique du code ci-dessus sera la suivante

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
int x;
x=malloc(sizeof(double));   // Stocker l'adresse de la zone allouée dans un entier
*x=3.1416;         // Stocker un double dans la zone allouée

Et, là est le problème, tu n'as rien précisé de ce qu'était "étoile x". Il est bien écrit "x est un nombre" mais rien sur "étoile x". Et donc le compilo ne peut pas travailler avec "étoile x" s'il ne sait pas ce que c'est.

Donc pour régler le problème, il te faut revenir au début de ton code et préciser que "étoile x" est un double. D'où la syntaxe suivante

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
double *x;        // J'informe le compilo de ce qu'est "étoile x"
x=malloc(sizeof(double));   // Stocker l'adresse de la zone allouée dans x qui, reste un entier
*x=3.1416;         // Stocker un double dans la zone allouée qui est maintenant connue comme un double

Maintenant, le compilo sait que "étoile x" est un double et peut travailler avec.

Toutefois, rien ne t'interdit de modifier le typage de la zone après coup (voire de l'utiliser différemment)

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
double *x;
int *y;                         
x=malloc(sizeof(double));
*x=3.1416;
printf("contenu de *x: %f\n", *x);    // Je regarde ce qu'il y a dans la zone
 
y=x;           // Je copie l'adresse de la zone dans y (x et y étant 2 pointeurs donc deux objets identiques, c'est autorisé)
printf("contenu de *y: %d\n", *y);       // Je regarde ce qu'il y a dans la zone

Bien entendu, la façon de coder les int et les double étant totalement différente, le compilo tentant de décoder à la façon d'un int ce qui a été codé à la façon d'un double te sortira n'importe quoi. Mais il n'y a aucune irrégularité vis à vis de la norme dans ce code (surtout qu'un int étant plus petit qu'un double, le compilo ne dépassera pas la zone allouée pendant qu'il récupère ce qu'il y a...)

**Thierry Chappuis** · 20/12/2011, 20h27

Ton code fonctionne tant que l'adresse stocké dans la variable x satisfait les contraintes d'alignement pour un entier de type int et pour un double, ce qui est garanti par malloc():

Envoyé par n1256 §7.20.3

The pointer returned if the allocation succeeds is suitably aligned so that it may be assigned to a pointer to any type of object

Par contre, ceci est à mon avis un comportement indéterminé:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
int main(void)
{
    double pi = 3.1415;
    int *p = (int *) &pi;
 
    printf("Contenu de *p = %d\n", *p);
 
    return 0;
}

Avec mes meilleures salutations

Thierry

**diogene** · 20/12/2011, 20h29

@Sve@r (controverse fréquente)

Ce qu'il faut bien comprendre, c'est que pour le C, une adresse n'est qu'un nombre.

C'est très trompeur (et discutable) d'assimiler une adresse à un nombre (entier) : les opérations définies sur les adresses ne sont pas celles définies pour les entiers. Il n'y a pas d'isomorphisme entre les deux ensembles qui permette de les assimiler.

A priori, rien ne t'interdit d'écrire...

Le compilateur va renacler.

@ dafpp

si on alloue de la mémoire et que l'on cast pas, cela convertira automatiquement de void * (le retour d'adresse de malloc) au type de la variable qui reçoit l'allouement de mémoire ?

Oui, à condition que le type de la variable soit un pointeur.

donc si c'est oui, le type de la variable est lié á la variable, lors de l'execution, donc si on alloue de la mémoire avec une variable d'un autre type mais qui pointe vers l'autre d'un autre type, est ce que allouer de la mémoire sur cette dernière variable changera qqchose ?

J'ai rien compris.

**dafpp** · 20/12/2011, 21h47

D'accord, donc l'important est de faire attention aux types qu'on utilise.

j'ai toutes mes réponses, et je crois bien que c'est clair.

merci à tous !

**Sve@r** · 20/12/2011, 23h09

Envoyé par diogene

@Sve@r (controverse fréquente)
C'est très trompeur (et discutable) d'assimiler une adresse à un nombre (entier) : les opérations définies sur les adresses ne sont pas celles définies pour les entiers. Il n'y a pas d'isomorphisme entre les deux ensembles qui permette de les assimiler.

C'était une illustration métaphorique pour expliquer la façon de voir "générale". Bien entendu, dans le détail ce n'est plus vrai. Tout comme en physique où certaines lois sont utilisées dans certaines conditions bien qu'elles deviennent fausses dans d'autres conditions plus extrêmes. Ainsi à l'étudiant qui apprend les moments des forces et qui fait un contrôle où par exemple il est question d'un avion dont il doit calculer la vitesse on lui dira probablement que les frottements d'air sur les ailes sont négligeable ; mais à un ingénieur aéronautique qui doit dessiner une aile d'avion, il en ira tout autrement dans ses calculs. Et donc à chaque population on adapte son discours (voire même on élague certains détails) pour essayer de faire comprendre au mieux quitte à y revenir ensuite quand les bases de la compréhension sont posées et acquises...

Envoyé par diogene

Le compilateur va renacler.

Oui, parce qu'il est prévu pour refuser certaines actions visiblement erronées. Et c'était juste un exemple illustratif de la notion et non un exemple fonctionnel...

Envoyé par Thierry Chappuis

Par contre, ceci est à mon avis un comportement indéterminé:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
int main(void)
{
    double pi = 3.1415;
    int *p = (int *) &pi;
 
    printf("Contenu de *p = %d\n", *p);
 
    return 0;
}

A mon avis, ça fonctionnera parce que l'int est plus petit que le double. Donc si la zone double commence à l'adresse 0x1000; alors les octets de 0x1000 à 0x1007 seront protégés et utilisables. Ensuite ben que tu stockes ce 0x1000 dans un autre pointeur puis que tu ailles lire les octets de 1000 à 1003 ne pose pas de souci.

Ce qui pourrait en poser, ce serait de faire ça dans l'autre sens

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
int main(void)
{
    int *p = 123;
    double *db = (double *) &p;
 
    printf("Contenu de *db = %f\n", *db);
 
    return 0;
}

Parce que là, on va aller lire les octets de 0x1000 à 0x1007 alors que seuls les octets de 0x1000 à 0x1003 sont protégés. Et peut-être que les 4 octets suivants sont en dehors de la zone du programme...

**Thierry Chappuis** · 21/12/2011, 09h30

Si l'adresse stockée dans le pointeur p satisfait les contraintes d'alignement pour un entier de type int, c'est OK. Dans le cas contraire, le comportement est indéterminé.

Avec mes meilleures salutations

Thierry