QFLAGS : signed value is out of range for enum constant

[jsulm]

@MNGL Please provide more information.
What is this enum (where is it defined)?
What Qt version and compiler?

[Christian Ehrlicher]

@MNGL said in QFLAGS : signed value is out of range for enum constant:

"xxxxx920P4". And I found out in the debugging that 'xxxxx920P4' is now equals to "xxxxxundefine"( 0x00000000),

I doubt so. 0x00000000 is neither signed nor can it be out of range for QFlags. Do you mean 0x100000000?
0x100000000 is greater than an integer can hold so you can't use it for a plain enum, no problem of QFlags. See http://c0x.coding-guidelines.com/6.7.2.2.html

[KroMignon]

@MNGL said in QFLAGS : signed value is out of range for enum constant:

warning C4341: 'xxxxx920P4' : signed value is out of range for enum constant

As @Christian-Ehrlicher already sayed, xxxxx920P4 = 0x100000000 needs at least 33 bit, this cannot be hold in an integer which have 32 bit ;)

You can try to force enum type to long long: enum Version : qint64 { ... }, this should works with C++ 11 at least.

[MNGL]

Qt version: 4.8.7

Compiler: Visual studio 2010:

Following loop will not executed. gVersions[0].verNum is "xxxxx920P4", so I guess "xxxxx920P4"'s value has been truncated and now it equals to "0x00000000".
for(int i=0; gVersions[i].verNum != xxxxxundefine ; i++)
{

}

[jsulm]

@MNGL said in QFLAGS : signed value is out of range for enum constant:

for(int i=0; gVersions[i].verNum != xxxxxundefine ; i++)

Well, what do you think will happen if "gVersions[i].verNum != xxxxxundefine" never becomes false?

[MNGL]

@jsulm said in QFLAGS : signed value is out of range for enum constant:

xxxxxundefine

"xxxxxundefine" is also in the gVersions[], "gVersions[i].verNum != xxxxxundefine" will become false.

[jsulm]

@MNGL said in QFLAGS : signed value is out of range for enum constant:

will become false

Well, if you are sure.
Else your app will crash with out of bounds exception. It is always a good idea to check the index for being in range.

[MNGL]

Unfortunately, I'm the guy who gonna maintain this project, the guy who design this did not expect the enum value will be out of range in less than 40 items.

[JonB]

@MNGL said in QFLAGS : signed value is out of range for enum constant:

did not expect the enum value will be out of range in less than 40 items

Your enum is a bit-flags enum. It does not hold sequential values (1, 2, 3, 4, ...), it holds sequential bits (1, 2, 4, 8, ...). So if you only give it 32-bits it will hold... up to 32 values. 40 items is not going to fit into it!

[MNGL]

Hi, guys. Is there any example on using QBitArray to replace QFlag(bitmask enum in my case)?

[jsulm]

@MNGL Did you try what @KroMignon suggested?

[MNGL]

@jsulm Yes, I have. The QFlag class only works with int or unsinged int. https://doc.qt.io/qt-5/qflags.html.

Let'd assume we can use qint64 it just provides extra 32 items and will be used up soon in my case.

[jsulm]

@MNGL Well, QBitArray and QFlag are two different things. You can't use QBitArray in code which expects QFlag.

[MNGL]

@jsulm

In below post, BitArray is mentioned as alternative solution.
https://stackoverflow.com/questions/1060760/what-to-do-when-bit-mask-flags-enum-gets-too-large

I guess I have to get ride of following QFlag code and rewrite the whole thing.

if(Versions.testFlag(xxxxx920P4) )

[KroMignon]

@MNGL said in QFLAGS : signed value is out of range for enum constant:

Let'd assume we can use qint64 it just provides extra 32 items and will be used up soon in my case.

Just out of curiosity, it is not easier to change the "nature" of the enum and use plain values and not bit field?
Do you really need a bit field?

It maybe easier to replace the bitfield enum with and plain value enum and use QList/QVector on situation where you need to handle multiple values.

Just my 2 cts.

[MNGL]

     typedef enum
    {
        Undefined  = 0x00000000,
        H1      = 0x00000001,
        H2      = 0x00000002,
        H3      = 0x00000004,
 
    } Hardware;
    Q_DECLARE_FLAGS(Hardwares, Hardware)

    typedef struct
    {
        Version          verNum ;
        Hardwares   supportedHW ;
	    
    } Settings ;

    const Settings gSettings[] =
   {                                    
       {   xxxxx400 ,         H1|H2|H3  },
       {   xxxxx401 ,         H1|H3   },
   } ;

Now the "Hardwares" type is to store combinations of Hardware values. Due to the range limit, I want to change "supportedHW" to a different data structure. I tired following type:

 QList<Hardware>     supportedHW;   //Got compiling errors:error C2552: 'supportedHW' : non-aggregates cannot be initialized with initializer list
 Hardware  supportedHW[4] ;   //pass compile, but not easy to use as QList and QFlags

Any suggestions? Thanks.

[jsulm]

@MNGL @KroMignon asked you whether your enum really has to contain bitfields: means 2^x values (0001, 0010, 0100, ...).
If this is not required then use just normal numbers, then your range is what an int provides and is for sure enough.