can i cast a template instance with arg uint to same template instance with arg int - is it compliant - to which standard?

Question

Plz check following c++ code: (nothing special, should be compliant to c++ 2nd edition from 1991)

    class C
    {
            // also defines all the methods called in template method below with the obvious name and args.
    
            public: template<typename TEnum> void SetNullableEnumValuePtr(CNullable<TEnum>* aEnumPtr)
            {
                if(sizeof(TEnum) == 4)
                {
                    this->SetNullableUInt32Ptr(reinterpret_cast<CNullable<UInt32>*>(aEnumPtr));
                }
                else if (sizeof(TEnum) == 2)
                {
                    this->SetNullableUInt16Ptr(reinterpret_cast<CNullable<UInt16>*>(aEnumPtr));
                }
                else if (sizeof(TEnum) == 1)
                {
                    this->SetNullableUInt8Ptr(reinterpret_cast<CNullable<UInt8>*>(aEnumPtr));
                }
                else
                {
                    this->FailEnumSize();
                }
            }
    }

basic conditions class CNullable follows the well known, basic nullable pattern implemented i.e. for c# in certain frameworks but could also be any template with one argument.

as the names imply, TEnum is used for different enum types. i.e. enum FooEnum { foo };

For different platforms/compilers it is true, that with for the same enum type it goes to different if branches: On Win32 all enums are compiled with a size of 4 bytes always. On my MCU it compiles to uint8, if the values of the enum field implies to do so.

1. Not my focus: i'm not sure, if the c++ standard allows compliant compilers to generate enums with different sizes in respect of the required size but i think it is said, that it is compliant.

2. not my focus: it is also obvious that a cleaner / more robust solution would generate explicit template instances for the function for ALL used enum types. however i might do this and hope the compiler/optimizer is smart/compliant enough not to generate extra code for all types.

3. Not my focus: i know that reinterpret_cast can be evil but there is a reason the c++ standard defines it. so please stop downrating my questions just because you dont like it or dont understand it.

4. Not my focus: i know there are certain websites, you can test code on different compilers.

5. would help too: also if you have a better idea how to treat this coding issue you're welcome.

6. My focus:

i wanna focus this question on the issue, if the c++ standard [1] (or any other standard) defines rule(s), that the templates instances for intXX and uintXX (Where XX is the bit width and u indicates a unsigned version of the native integer) must forcefully compile to a code where a reinterpret_cast from CNullable<unsigned intXX> to CNullable<intXX> is guaranteed to run properly. it seems to be likely that a straight forward implementation of the tool chain may not cause problems in this case, but i got used to be carefull with such assumptions.

conclusion: if one could give me the reference(s) to chapter inside the (c++) or other standard treading these issues (1 to 6) - that would be great.

thank you!

[1] Please understand the sad reality, that the platform i work on does even not have a ready compiler specification. so it is quite trial and error and i wanna understand the techniques behind to get a better feeling for it - because treading the issue deterministic seems not to be possible since the compiler reference does not give a clear statement what standard it supports: They stated an ETSI standard rather than an iso c++ standard and they didnt give enough info to find the documentation of the standard - no version number, no document number, no document name. when i search for the info given in the compiler documentation on the ETSI page i get > 24.000 results (!) XD

PS: Edit: I request the info: a) Which standards / specifications ensure that this code runs properly?

b) Does anyone have a clean solution for an abstraction using different template instances for different enum types?

Answer 1

Ok think i i have a clean solution. It uses a wrapper pattern to hide the abstraction of concrete value types behind a virtual method.

I hope that is enough code to get the intention. I also put a very simple example of how i use it.

I guess in newer c++ version there are some stl elements which can replace the classes i wrote. But i need it for a very old c++ standard, which even isn't iso.

I really hope there are no errors since not all symbols are defined. but the essential stuff shall be shown in this example implementation.

// platform dependent UInt32 type.
typedef unsigned __int32 UInt32;

template<typename T>
class CNullable
{
        public: bool HasValue;
        public: T Value;
        public: CNullable(): Value(), HasValue(false) {}
        public: CNullable(const T& aValue): Value(aValue), HasValue(true) {}
        public: template<typename T1>
        CNullable<T1> To() const
        {
            return this->HasValue ? CNullable<T1>(static_cast<T1>(this->Value)) : CNullable<T1>();
        }    
        CNullable<UInt32> ToU32n() const
        {
            return this->To<UInt32>();
        }
};

// U32-Nullable type
typedef CNullable<UInt32> UInt32n;

// U32-Nullable argument type.
typedef const CNullable<UInt32>& UInt32na;


// Some kind of variant value that can store different types of values pointing into an (intended) statically allocated model 
class CValue
{

    // Report failure. Break debuger, raise exception, log error - whatever.
    private: static void Fail(const char* aTextPtr);

    // Sets the value in the (intended) statically allocated datamodel
    // Simple example with a UInt32 as new value
    public: void SetTargetValue(UInt32na rhs);

    // Sets the value in the (intended) statically allocated datamodel
    // May use a visitor pattern (GOF) for resolving assigned types, but thats not the topic here.
    public: void SetTargetValue(const CValue& rhs);

    // Ensures that object is not sealed an fails if so.
    private: bool CheckNotSealed();

    // Allows to change to sealed state to protect the object agains modification.
    // protection for "as static as possible"-memory-design
    public: void Seal();

    // Base class for Wrappers
    class CValueWrapper
    {
    public: virtual ~CValueWrapper() {}
    // Converts the current value as an U32.
    public: virtual UInt32n GetInterpretedU32n() { Fail("Data conversion not supported."); return UInt32n(); }

    // converts the new value from an U32 and sets the value
    public: virtual void SetInterpretedU32n(UInt32na aU32n) { Fail("Data conversion not supported."); }
    };

    // Wrappers Base class for any enum related type.
    class CEnumWrapperBase : public CValueWrapper
    {
    public: virtual UInt32n GetU32n() const = 0;
    public: virtual void SetU32n(UInt32na aU32n) const = 0;
    public: virtual UInt32n GetInterpretedU32n() { return this->GetU32n(); }
    public: virtual void SetInterpretedU32n(UInt32na aU32n) { this->SetU32n(aU32n); }
    };

    // Wrapper base class for values of type = Nullable<TEnums> 
    template<class TEnum> class CNullableEnumWrapper : public CEnumWrapperBase
    {
        private: CNullable<TEnum>* mNullableEnumPtr;
        public: CNullableEnumWrapper(CNullable<TEnum>* aNullableEnumPtr)
            :
            mNullableEnumPtr(aNullableEnumPtr)
        {
        }
        public: virtual UInt32n GetU32n() const
        {
            return this->mNullableEnumPtr ? this->mNullableEnumPtr->ToU32n() : UInt32n();
        }
        public: virtual void SetU32n(UInt32na aU32n) const
        {
            if (this->mNullableEnumPtr)
            {
                *this->mNullableEnumPtr = aU32n.To<TEnum>();
            }
        }
    };

    // Wrapper base class for values of type = Nullable<TEnums> 
    template<class TEnum> class CEnumWrapper : public CEnumWrapperBase
    {
        public: CEnumWrapper(TEnum* aEnumPtr)
            :
            mEnumPtr(aEnumPtr)
        {
        }
        private: TEnum* mEnumPtr;
        public: virtual UInt32n GetU32n() const
        {
            return this->mEnumPtr ? static_cast<UInt32>(*this->mEnumPtr) : UInt32n();
        }
        public: virtual void SetU32n(UInt32na aU32n) const
        {
            if (this->mEnumPtr
                && aU32n.HasValue)
            {
                *this->mEnumPtr = static_cast<TEnum>(aU32n.Value);
            }
        }
    };

    // Allows to lock instantian of wrapper objects. 
    // In my bare metal application all wrappers are created on application startup 
    // and stay allocated until the device is switched of (by disconnecting power)
    // [ThreadStatic]
    public: static bool InstanciateValueWrapperEnabled;

          // Set pointer to enum value (intended to be allocated in a static model)
    public: template<class TEnum> void SetEnumValuePtr(TEnum* aEnumPtr)
    {
        if (this->InstanciateValueWrapperEnabled)
        {
            if (this->CheckNotSealed())
            {
                this->SetValueWrapperPtr(new CEnumWrapper<TEnum>(aEnumPtr), true);
            }
        }
        else
        {
            Fail("Invalid operation.");
        }
    }

          // Set pointer to nullable<enum> value (intended to be allocated in a static model)
    public: template<class TEnum> void SetNullableEnumValuePtr(CNullable<TEnum>* aEnumPtr)
    {
        if (this->InstanciateValueWrapperEnabled)
        {
            if (this->CheckNotSealed())
            {
                this->SetValueWrapperPtr(new CNullableEnumWrapper<TEnum>(aEnumPtr), true);
            }
        }
        else
        {
            Fail("Invalid operation.");
        }
    }


          // Sets the member var and data type to 'CValueWrapper' (may support some types natively without a wrapper object)
    public: void SetValueWrapperPtr(CValueWrapper* aValueWrapperPtr, bool aOwning);

};

// Model Base Code
//////////////////////////////////////
/// Application specific code

enum FooEnum { FooEnum_Val1 };

// Reads data from StdIn, uart, or whatever.
UInt32 ReadU32();

// Process data, for example output calculated data to another hardware interface.
void Process(CValue** aValuePtrs);

// Simple example of how its being used.
// in real environment its likely to encapsulate a set of CValue objects 
// in a ModelInstance-Object and build it by a ModelDefinition object parsing a model definiton language (mdl) 
// or adapt generated code. etc. etc...
void main()
{
    // Define the static model:
    static FooEnum gFooEnum;
    static CNullable<FooEnum> gNullableFooEnum;

    // Define the values to access the static model
    CValue aFooEnumVal;
    CValue aNullableFooEnumVal;

    // Begin of init:
    CValue::InstanciateValueWrapperEnabled = true;
    aFooEnumVal.SetEnumValuePtr(&gFooEnum);
    aNullableFooEnumVal.SetNullableEnumValuePtr(&gNullableFooEnum);
    CValue::InstanciateValueWrapperEnabled = false;
    // End of init

    // Create an array of values
    const UInt32 aPropertyCount = 2;
    CValue* aPropertyPtrs[aPropertyCount] =
    {
        &aFooEnumVal,
        &aNullableFooEnumVal
    };

    for (UInt32 aIdx = 0; aIdx < aPropertyCount; ++aIdx)
    {
        aPropertyPtrs[aIdx]->Seal();
    }

    // Very simple and unsave data receiption loop.
    while (true) 
    {
        UInt32 aPropertyIdToSet = ReadU32(); // The property id to receive.
        UInt32 aNewValHasValue = ReadU32();  // Wether the value is defined
        UInt32 aNewValValue = ReadU32();     // The value
        UInt32n aNewVal                      // Nullable for NewValue 
            = aNewValHasValue                // if value is defined
            ? UInt32n(aNewValValue)          // Create a nullable which has a value
            : UInt32n()                      // Create a nullable which has no value
            ;
        CValue* aValuePtr = aPropertyPtrs[aPropertyIdToSet]; // Get the value to receive.
        aValuePtr->SetTargetValue(aNewVal);                  // Set the value to the static model
        Process(aPropertyPtrs);                              // Process data newly received.
    }
}