Taille d'une variable en C [Fermé]

Signaler
-
fiddy
Messages postés
11137
Date d'inscription
samedi 5 mai 2007
Statut
Contributeur
Dernière intervention
18 octobre 2016
-
Bonjour,

Pouvez-vous m'aider s'il vous plaît ?
Je voudrais connaitre la taille d'un char *

Je sais que pour une variable du type char [taille], on peut récupérer la taille en faisant un sizeof.
Par contre, pour un char *, je ne sais pas.
J'avais pensé faire un malloc, puis un sizeof :
char * toto;
toto=(char *)malloc(20);
Mais cela ne me retourne pas 20 mais 4 quelque soit le nombre passé en paramètre du malloc.

Pour info, je travaille sur les systèmes d'exploitation Unix et Linux.

J'avais pensé également au strlen mais il ne me retourne pas ce que je veux.

J'espère avoir été assez claire et surtout qu'il existe une solution à mon problème.

Merci de votre aide.

Mathilde

7 réponses

Messages postés
488
Date d'inscription
vendredi 16 avril 2004
Statut
Membre
Dernière intervention
15 mars 2009
156
hello!

sizeof (toto) renvoie la taille du pointeur sur char
(4 octets, soit 32 bits, soit 2^32 octets d'adressage)
sizeof(*toto) renvoie la taille d'un caractere (1 octet)
car sizeof ne compte pas les caracteres jusqu'au zéro terminal
et que la taille d'un type de variable n'est pas un nombre d'éléments. char * est un type, pas un espace mémoire.
strlen (toto) renvoie la taille de la chaine de caracteres (pas 20, car il ignore la taille allouée et compte les caractères jusqu'au 0).
Le C est un language système, son compilateur ne rajoute pas de
code pour contôler les espaces mémoire alloués, ce qui empêcherait d'avoir un contrôle total de ce qui est compilé, ralentirait le code et augmenterait sa taille (c'est anti C).
il n'y a rien qui retournera 20

voilà le seul moyen de récupérer la taille allouée :
int i=20;
char *toto;
if ( (toto =(char *) malloc(i))==null) i=0;

//cordialement
3
Merci

Quelques mots de remerciements seront grandement appréciés. Ajouter un commentaire

CCM 77266 internautes nous ont dit merci ce mois-ci

Messages postés
1708
Date d'inscription
lundi 15 septembre 2003
Statut
Contributeur
Dernière intervention
4 septembre 2010
498
Salut,

Bon je me rappelle plus sous Linux comment sont représentées les données mais 4 semble le bon chiffre.
En effet tu veut récuperer la taille d'un pointeur (c'est à dire une adresse = un entier).
Donc que tu fasses un pointeur sur un entier, un tableau de caractère, ou même une structure plus complexe ton pointeur sera toujours un entier (donc 4octets).

Voila j'espere que je t'ai aidé
A bientot.

;-)
~ ~ Fada ~ ~ : Member of Star!alco
Merci.

Mais puis-je récupérer le chiffre passé en paramètre du malloc grâce à une commande comme je le ferais pour un char[taille] par exemple ?

Merci encore.

Mathilde
Messages postés
3740
Date d'inscription
jeudi 22 avril 2004
Statut
Contributeur
Dernière intervention
17 décembre 2004
28
Bonjour ou Bonsoir,

Si tu veux recuperer la taille de ton mot et non pas la taille d'un pointeur strlen doit marcher.
D'apres mes souvenirs quelques precautions :
1 trouver dans quel include est mis la fonction. je ne sais plus si c'est de base mais il me semble que #include <string.h> ou #include <ctype.h> devrait etre bon.
2 il me semble qu'il y a juste une difference de plus ou moins 1 dans la taille d'un mot (je sais plus si il compte le '\0' ou non).

Good luck.

JSS
Yop,

ben en fait quand tu fais un malloc essaye plutot :

char *toto;
toto = (char *)malloc(sizeof(char));

Au moins tu devrais avoir la taille d'un caractère.

++

Nico
toto = (char *)malloc(sizeof(char));?
vu que sizeof(char) == 1, autant faire toto = malloc (1) voir char toto;
non, car ce code n'est alors plus réutilisable (quelle que soit la taille de char ou quel que soit le type qui remplace char).
Principe de base de la programmation, la ré-utilisabilité du code.
d'autre part, si le malloc retourne null, alors l'allocation n'est pas possible
et ne sera donc pas effectuée, d'où l'expression
if ( (toto =(char *) malloc(i))==null) i=0; qui permet de remplacer un segmentation fault par une sortie de programme (ou de fonction).
fiddy
Messages postés
11137
Date d'inscription
samedi 5 mai 2007
Statut
Contributeur
Dernière intervention
18 octobre 2016
1 661
quelle que soit la taille de char
La taille de char est fixe et vaut 1 byte.

quel que soit le type qui remplace char
Moui, mais dans ce cas, à la place de mettre sizeof(char), utilise plutôt sizeof *toto. Ainsi si tu changes le type de la variable toto, le code restera correct.

if ( (toto =(char *) malloc(i))==null) i=0;
Ce n'est pas null mais NULL. Et pour info, le cast est superflu.
-> Ce n'est pas null mais NULL. Et pour info, le cast est superflu.

NULL est une macro de type #define NULL ((void*)0)

La fonction malloc retourne un type void, et toto est de type char, d'où génération d'un avertissement à la compilation.
et même si ce n'était pas le cas, on mettrait quand même le casting pour la lisibilité du code.
fiddy
Messages postés
11137
Date d'inscription
samedi 5 mai 2007
Statut
Contributeur
Dernière intervention
18 octobre 2016
1 661
NULL est une valeur standard. Alors que null n'existe pas.
Après libre à toi, si tu as envie de redéfinir des types déjà existants. Genre NuLl ou null.

La fonction malloc retourne un type void
Non ce n'est pas void, mais void*. Ca change tout. J'y reviens au paragraphe suivant.
Pareil, toto est de type char* (et non char).

d'où génération d'un avertissement à la compilation.
Non. Aucun compilateur ne mettra d'avertissement. La promotion du type générique (void*) en un type concret (comme char*) est implicite.D'ailleurs, c'est là tout l'intérêt de ce type.

on mettrait quand même le casting pour la lisibilité du code.
Cela surcharge plus le code qu'autre chose et n'apporte aucune lisibilité supplémentaire.
Autant cette surcharge était nécessaire en K&R (pour des raisons historiques), mais elle ne l'est plus du tout. D'ailleurs c'est déconseillé, car ce cast empêchera certains compilateurs de détecter si l'entête <stdlib.h> a été inclu ou non.
void est un type abstrait par définition (même void*)

La surcharge, c'est une propriété permettant le polymorphisme dans les langages objet (c'est à dire qu'on puisse passer plusieurs types de variables à une fonction pour un même paramètre) , et le C n'en est pas un.
(est ce que l'objet a simplifié la compréhension d'un programme ?
pas sûr, mais c'est un autre débat)

La lisibilité est: de quel type parle-t-on ?

- Dans certains encodages et dans certains systèmes d'exploitations, il existe des types char qui peuvent tenir sur 2 octets (utf8 utf16, utf32)
fiddy
Messages postés
11137
Date d'inscription
samedi 5 mai 2007
Statut
Contributeur
Dernière intervention
18 octobre 2016
1 661
void est un type abstrait par définition (même void*)
Certes, mais ils ne sont pas synonymes. malloc renvoie un void* et non un void...

La surcharge, c'est une propriété permettant le polymorphisme dans
Avant d'être un mot "informatique", le mot "surcharge" est un mot français. Quand je parle de surcharge, cela signifie que cela rend le code plus lourd, moins lisible.

La lisibilité est: de quel type parle-t-on ?
Bon ok, affaire de goût. Si tu préfères mettre un cast inutile, car tu trouves ça plus clair, beh continue.

Dans certains encodages et dans certains systèmes d'exploitations, il existe des types char qui peuvent tenir sur 2 octets (utf8 utf16, utf32)
Encore ne faut-il pas confondre byte et octet. Quel que soit l'implémentation, un char vaut 1 byte (sizeof (char) = 1) d'au moins 8 bits. Libre à toi de faire tenir le byte sur 2 octets. Mais cela ne changera pas la valeur de sizeof(char).