Version imprimable
Bonjour,
je déclare certaines variables avec le size_t de stddef.h.
Imaginons une variable var de type size_t.
Si je veux poser i = var-1, comment doit-être déclaré i?
Je suis allé chercher dans stddef.h pour savoir.
J'ai trouvé ssize_t mais ça ne convient pas :
size_t équivaut unsigned long int,
ssize_t équivaut à long int.
La valeur maximale que peut prendre size_t dépasse nettement celle que peut prendre ssize_t.
Connaissez-vous une manière de faire?
Bonjour,
En C++ le fichier d'en-tête est : <cstddef>.
ssize_t n'est pas défini par la norme (ni C ni C++). C'est je crois une définition POSIX. Potentiellement, elle peut être absente de certains compilateurs ou dépendant d'option de compilation.
Sinon, je ne comprend pas ton problème ? Pourquoi ne pas vouloir poser i = var-1 ave i un size_t si c'est sa sémantique (quitte à ce que cela implique comme précondition que var>0) ? Dit autrement le type de i doit dépendre de ce qu'il signifie aussi : taille, offset, index de boucle, etc ?
Oui, enfin bon, on peut toujours faire un petit typedef pour régler le problème.Citation:
Envoyé par 3DArchi
Par contre, si Aleph69 ne sait pas si sa variable a des chances d'être nulle, il ferait tout aussi bien de prendre un int, ou, long long (pour être sûr d'avoir toutes les valeurs possible du genre [-ULONG_MAX,ULONG_MAX]).
Attention, ça n'a rien d'obligatoire, par exemple, sous windows, en 64 bits, size_t est 64 bits alors que long reste 32 bits.Citation:
Envoyé par Aleph69
Merci beaucoup pour vos réponses.
Oui c'est justement pour cela que je l'utilise mais il manque le signé.Citation:
Attention, ça n'a rien d'obligatoire, par exemple, sous windows, en 64 bits, size_t est 64 bits alors que long reste 32 bits.Citation:
size_t équivaut unsigned long int
Pour faire simple, size_t correspond à une plage de valeurs [0,SIZE_MAX] etCitation:
Pourquoi ne pas vouloir poser i = var-1 ave i un size_t
size_t-1 correspond à une plage de valeurs [-1,SIZE_MAX-1].
Comment déterminer (automatiquement) le type de size_t-1?
Oui, par défaut j'ai pris long long mais je me demande si c'est vraiment pérenne.Citation:
Par contre, si Aleph69 ne sait pas si sa variable a des chances d'être nulle, il ferait tout aussi bien de prendre un int, ou, long long (pour être sûr d'avoir toutes les valeurs possible du genre [-ULONG_MAX,ULONG_MAX]).
Ce n'est pas forcément parfait non plus... Parce que long long (ou ssize_t) peuvent très bien être dans la plage [-SIZE_MAX/2+1,SIZE_MAX/2]...
Et au lieu d'avoir 1 cas qui ne marche pas, tu en as 50% !
La question à poser est pourquoi faire var-1 ? Le cas où var == 0 n'est-il pas quoi qu'il arrive un cas particulier, qu'il faudra de toute façon traiter à part ? Si oui, il n'y a aucun problème à déclarer i de type size_t.
size_t étant défini comme un unsigned int, long lon n'est-il pas forcément (strictement) plus grand qu'un int ? (rhaa, pourquoi y'a pas de norme gratuite sur le net :()Citation:
Envoyé par JolyLoic
Oui, je suis d'accord.Citation:
Ce n'est pas forcément parfait non plus... Parce que long long (ou ssize_t) peuvent très bien être dans la plage [-SIZE_MAX/2+1,SIZE_MAX/2]...
Et au lieu d'avoir 1 cas qui ne marche pas, tu en as 50% !
La question à poser est pourquoi faire var-1 ? Le cas où var == 0 n'est-il pas quoi qu'il arrive un cas particulier, qu'il faudra de toute façon traiter à part ? Si oui, il n'y a aucun problème à déclarer i de type size_t.
Je vais le traiter comme ça mais c'est dommage que ce ne soit pas prévu.
Non, c'est tout le problème : la définition de size_t varie ce n'est pas forcément un unsigned int. D'ailleurs chez moi c'est un unsigned long int.Citation:
size_t étant défini comme un unsigned int, long lon n'est-il pas forcément (strictement) plus grand qu'un int ? (rhaa, pourquoi y'a pas de norme gratuite sur le net )
En tous les cas, merci à tous pour votre aide.
Je vais attendre avant de marquer le sujet comme résolu, on ne sait jamais. ;)
Attention, ce n'est pas forcément vrai...Citation:
Envoyé par méphistopheles
Size_t est un type unsigned capable de représenter l'ensemble des adresses disponibles sur le système.
Sur ma version de Gcc (la 4.5.1), size_t est donc un typedef du symbole préprocesseur... __SIZE_TYPE__ qui sera lui-même défini sur base d'autres tests d'architecture et de système d'exploitation.
Et, chez moi, cela correspond à un unsigned long long et non à un unsigned int ((unsigned) int et (unsigned) long ayant, chez moi, la même taille, (unsigned)long long faisant le double de la taille d'eux:D)
Quoi qu'il en soit, size_t est de type non signé, et on ne peut donc pas envisager d'avoir des valeurs négatives (ou considérées comme telles).
S'il est cohérent, dans ta logique, d'avoir une valeur négative, il faut donc choisir un autre type que size_t (en fait, son équivalent non signé), autrement, il faudra effectivement traiter le cas où ta variable vaut 0 (avant calcul :D) comme un cas particulier et décider de ce qu'il y a lieu de faire ;)
Non, pas vraiment. Et il est différent sur certaines implémentations courantes.Citation:
Envoyé par méphistopheles
Non, il peut être identique. Et il est d'ailleurs identique sur pas mal d'architecturesCitation:
Envoyé par méphistopheles
http://www.open-std.org/jtc1/sc22/wg...2010/n3090.pdf en est un brouillon qui montre déjà pas mal de choses... Après, il faut aussi la norme C, car certains points y sont définis par référence.Citation:
Envoyé par méphistopheles
Il n'y a, en réalité, qu'une seule garantie, c'est que l'on a les (in)égalités suivantes:Citation:
Envoyé par méphistopheles
Pour le reste, tout dépend de l'implémentation et de l'architecture ;):P
- char <= short <= int <= long (int) <= long long (int)
- unsigned char <= unsigned short <= unsigned int <= unsigned long (int) <= unsigned long long (int)
- char == unsigned char
Au passage, pour compléter ce qui a déjà été dit, nul part dans le lien que tu donnes, il n'est question d'unsigned int. Il est seulement fait mention d'un type entier non signé (unsigned integral type), ce qui peut correspondre à unsigned int certes mais également à unsigned long, unsigned short, etc. voire à un type interne propre au compilateur utilisé.Citation:
Envoyé par méphistopheles
Ouillouillouillle je me fais taper sur les doigts moi :aie:
Désolé, j'ai mal lu la définition... et comme il se trouvait que c'était unsigned int chez moi, j'ai pas tilté.
C'est vrai que les types ne sont pas vraiment défini niveau taille.
Je connais du coups pas mal de personnes qui utilisent (en C) un équivalent type.h d'unix pour s'assurer d'avoir des de taille définie... et qu'un uint32 soit bien sur 32 bits etc.... par contre, je ne sais vraiment pas si c'est optimal niveau compilateur :s...
Non, capable de représenter les tailles des objets. (size_t était 16 bits sur les compilateurs pour 8086 dans la plupart des modèles de mémoire alors qu'une adresse faisait 20 bits dans certains d'entre eux).Citation:
Envoyé par koala01
Au temps pour moi, tu as tout à fait raison...Citation:
Envoyé par Jean-Marc.Bourguet
Dans les implémentations récentes (ou peut être pas, d'ailleurs :aie:) l'alias capable de représenter l'ensemble des adresse est ptr_t :P
S'il n'est pas exclu que sizeof(ptr_t) puisse être égal à sizeof(size_t), ce ne sera que par le hasard de l'implémentation :aie: