Is a forced integer buffer overflow legitime? - c++

Question

I want to implement a Handletype like in this example.
(Long story short: the structure Handle holds an index-member to an array with elements. Its other member count validates if the index is up to date, corresponding to the datas countArray. count and countArray are with a fixed size of a type/bitfield( u32 : 20bits))
To avoid being restricted to the 20bits of the generation/counter size, the following came into my mind: Why not let the unsigned char count/countArray overflow on purpose?
I could also do the same with the modulo method ( counter = ++counter % 0xff ), but that is another additional operation then..
So let the count grow upto 0xff and overflow will set it again to 0 when 0xff + 1 happens.
Is this legitime?
Here is my pseudo implementation (C++):
struct Handle
{
unsigned short index;
unsigned char count;
};
struct myData
{
unsigned short curIndex;
int* dataArray;
unsigned char* countArray;
Handle create()
{
// check if index not already used
// create object at dataArray[handle.index]
Handle handle;
handle.index = curIndex;
handle.count = countArray[curIndex];
return handle;
}
void destroy( const Handle& handle )
{
// delete object at dataArray[handle.index]
countArray[handle.index]++; // <-- overflow here?
}
bool isValid( const Handle& handle ) const
{
return handle.count == countArray[handle.index];
}
};
EDIT #1: Yes, these integral types should all be unsigned (as indexes are)

Answer 1

As long as you're not using signed types, you're safe.
Technically, unsigned types don't overflow:
3.9.1 Fundamental types [basic.fundamental]
46)This implies that unsigned arithmetic does not overflow because a
result that cannot be represented by the resulting unsigned integer
type is reduced modulo the number that is one greater than the largest
value that can be represented by the resulting unsigned integer type.