Discussion :

[Pragmateek]

Bonjour,

est-il possible en C de récupérer la taille du type sous-jacent à un pointeur ver ce type ?

Cette syntaxe :

Code :

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

1
2
3
4
5
6
7
8
9
10
#include <stdlib.h>
 
typedef int* pint;
 
int main(void)
{
        size_t n = sizeof(*pint);
 
        return 0;
}

ne fonctionnant pas .

Merci .

[Médinoc]

Pour un type pointeur non, mais pour le pointeur lui-même ça marche:

Code C :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdlib.h>
 
typedef int* pint;
 
int main(void)
{
	pint p = NULL;
	size_t n = sizeof(*p);
 
	(void)n;
	return 0;
}

[Pragmateek]

Excellent .

Ceci fonctionne :

Code :

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

1
2
3
4
5
6
7
8
9
10
#include <stdlib.h>
 
typedef int* pint;
 
int main(void)
{
        size_t n = sizeof(*(pint)NULL);
 
        return 0;
}

Mais pourquoi le déréférencement d'un pointeur "NULL" est-il valide dans ce cas ?
Comment la norme définie t'elle cette possibilité ?

Merci .

[Thierry Chappuis]

Chez moi, ceci:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
 
typedef int* pint;
 
int main(void)
{
    pint p = NULL;
    size_t n = sizeof *p;
 
    printf("%u\n", (unsigned) n);
 
    return 0;
}

affiche:

Code :

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

1
2
thierry@pygnol:~$ ./test
4

Ceci dit, ce n'est pas une pratique recommandée de masquer un pointeur dans un alias de type. Même en préfixant le nom du type avec un "p", je ne suis pas fan de cette pratique.

Thierry

[Médinoc]

Mais pourquoi le déréférencement d'un pointeur "NULL" est-il valide dans ce cas ?

Parce que le pointeur n'est pas vraiment déréférencé.
C'est juste un calcul statique de type, fait lors de la compilation et non lors de l'exécution.

Ainsi, même si le pointeur n'est carrément pas encore initialisé, ça marche.
Et c'est d'ailleurs le cas quand on écrit ceci:

Code :

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

untype *p = malloc(sizeof (*p));

--> p n'est pas encore initialisé lors de l'appel de malloc().

[Pragmateek]

Ah oui exact .

Mais la norme ne semble pas imposer un calcul statique pour "sizeof", même si un calcul dynamique par une quelquonque implémentaion semble peu probable .

Que dire de la portabilité ?

[Médinoc]

Ça, je ne saurais dire, je n'ai jamais lu la norme en détails.

Mais je pense que le non-déréférencement doit être garanti, sinon la pratique que j'ai montrée serait bannie.

Quant à une évaluation dynamique, je ne pense pas qu'elle soit envisageable pour un pointeur, à moins qu'en C99 il soit possible de créer un pointeur sur VLA (car sizeof d'un VLA est dynamique, forcément).

[Thierry Chappuis]

Oui, le non-déréférencement est garanti!

Thierry

[Pragmateek]

Mais je pense que le non-déréférencement doit être garanti, la pratique que j'ai montrée serait bannie.

Oui, le non-déréférencement est garanti!

Ok, merci .

Aurais-tu les références de la norme s'il te plait ?

[diogene]

n1124 dit :

6.5.3.4 The sizeof operator
Constraints
1 The sizeof operator shall not be applied to an expression that has function type or an
incomplete type, to the parenthesized name of such a type, or to an expression that
designates a bit-field member.
Semantics
2 The sizeof operator yields the size (in bytes) of its operand, which may be an
expression or the parenthesized name of a type. The size is determined from the type of
the operand. The result is an integer. If the type of the operand is a variable length array
type, the operand is evaluated; otherwise, the operand is not evaluated and the result is an
integer constant.

[Emmanuel Delahaye]

Mais pourquoi le déréférencement d'un pointeur "NULL" est-il valide dans ce cas ?
Comment la norme définie t'elle cette possibilité ?

sizeof (*(pint)NULL) est une expression constante. Il n'y a pas de déréférencement.

[Pragmateek]

n1124 dit :

Merci pour les références .

D'autre part, sizeof (*(pint)NULL) est une expression constante. Il n'y a pas de déréférencement.

Ah oui en effet .
Est-ce vrai pour tous les types, y compris définis par l'utilisateur ?

Merci .

[Emmanuel Delahaye]

Ah oui en effet .
Est-ce vrai pour tous les types, y compris définis par l'utilisateur ?

Oui. une définition de type se traduit par des informations connues au moment de la compilation, donc tout est calculable par le compilateur et se réduit à une constante de type entier.

[C99] La question se pose pour les VLA qui sont effectivement évalués à l'exécution (évidemment).

[Pragmateek]

Ok, merci beaucoup à tous pour vos réponses .

[Pragmateek]

Apparemment cette méthode ne semble pas fonctionner avec les structures .

Ceci :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdlib.h>
 
struct {
        int n;
}structure;
 
typedef struct structure* Structure;
 
int main(void)
{
        size_t n = sizeof(*(Structure)NULL);
        return 0;
}

provoque l'erreur de compilation :

Code :

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

error: dereferencing pointer to incomplete type

Où est l'erreur ?

Merci .

[Médinoc]

Dans ton code, le type struct structure n'existe pas.
Il n'y a qu'un type struct anonyme également appelé structure.

Ce qui fait que structure et struct structure sont deux types radicalement différents.

[Pragmateek]

Oups en effet.

Merci .