Taille d'un Enuméré...

Version imprimable

04/08/2004, 12h11
kris1980

Taille d'un Enuméré...

Bonjour, j'utilise Dev-C++ !
Lorsque je fais un sizeof d'un énuméré le fonction me retourne 4.
Pour certaine raison j'aurais besoin que le sizeof me retourne 1.
Mon énuméré pourra seulement avoir 256 valeurs...

Comment faire ??

Merci :wink:
04/08/2004, 12h14
Grulim

tu peux pas faire qu'un enum est une taille 1, c'est comme si tu voulais qu'un long est une taille de 1 octet !!!!
04/08/2004, 12h14
freddy766

Salut,
Tu veux seulement récuperer la taille(et obtenir 1) ou Modifier cette taille (pour qu'elle fasse 1)?
04/08/2004, 12h18
kris1980

Je pense que c'est possible, sous un compilateur Borland C++ on peut utiliser :
#pragma option -b-
enum TEnumByte { a, b, };
#pragma option -b.

Je cherche quelque chose sous gcc !

:wink:
04/08/2004, 14h33
Grulim

simple curiosité: quel est l'intérêt ?
04/08/2004, 14h50
kris1980

j'ai besoin de ceci pour faire une migration d'un programme écrit sous BCC 5.02 en GNU GCC... Trop long à t'expliquer... désolé ! :? :roll:
04/08/2004, 17h24
Grulim

Citation:

Envoyé par kbogos

j'ai besoin de ceci pour faire une migration d'un programme écrit sous BCC 5.02 en GNU GCC... Trop long à t'expliquer... désolé ! :? :roll:

ben tant pis, alors :(

je ne peut pas t'aider, je n'ai pas GCC...
de plus j'ai cherché l'équivalent VC2003 et j'ai pas trouvé...
mais ça me parait quand même bizarre (et surtout contraire au standard C++).

Tu peux toujours essayer de te définir un type de la taille d'un char et exposer des fonctions qui permettent les convertions avec un enum.

Code:

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
// pondu à la va-vite
#include <iostream>
 
template <typename E>
struct enum8bits_impl
{
    typedef E enum_type;
 
    enum8bits_impl(enum_type v) : value_(v) {}
 
    struct reference_type
    {
        reference_type(enum8bits_impl & e) : referenced_(e) {}
        reference_type & operator=(enum_type v) { referenced_.value_ = v; }
    private:
        enum8bits_impl & referenced_;
    };
    operator reference_type()       { return reference_type(*this); }
    operator enum_type()      const { return static_cast<enum_type>(value_); }
private:
    friend struct reference_type;
    char value_;
};
 
    enum E_NBS {zero, un, deux, trois,};
    enum E_IDX {i, j};
int main (int argc, char **argv)
{
    // typedef enum8bits_impl<enum {un, deux, trois}> e_nbs;
    typedef enum8bits_impl<E_NBS > e_nbs;
    e_nbs n = un;
    e_nbs::reference_type r (n);
    r = trois;
    E_NBS N = n;
    N = deux;
    // e_nbs n = i; // erreur
    // n = i; // erreur
    std::cout << n << " -- " << sizeof(n) <<std::endl;
    std::cout << std::endl;
 
    return  0;
}

La classe proxy est très certainement incomplète, mais c'est l'idée. En supposant que tu doives absolument avoir des enumérés de petite taille.

05/08/2004, 10h42
kris1980

Environ 6 heures aprés j'ai enfin trouvé la solution, je remerci d'avance tous ceux qui ont cherché !

en Bcc :

#pragma option -b-
enum TEnumByte { a, b, };
#pragma option -b.

en Gcc :

typedef enum {a,b} TEnumByte __attribute__ ((mode(__byte__)));

merci encore ! :D :D :lahola:
30/07/2009, 11h46
liberforce

Pour ceux qui comme moi pensaient que la taille d'un enum est la taille d'un int... Apparemment c'est inexact, il peut prendre n'importe quelle taille d'un type entier selon les valeurs qui lui sont affectées. Sauf... que c'est laissé à l'appréciation du compilateur. Certains compilateurs (gcc ?) laisseront donc la taille d'un int par défaut, alors que d'autres réduiront sa taille au minimum.