Discussion :

[kris1980]

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

[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 !!!!

[freddy766]

Salut,
Tu veux seulement récuperer la taille(et obtenir 1) ou Modifier cette taille (pour qu'elle fasse 1)?

[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 !

[Grulim]

simple curiosité: quel est l'intérêt ?

[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é !

[Grulim]

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é !

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++).

[Luc Hermitte]

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 :

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
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.

[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 !

[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.