Initializing C struct with unions declared in C++17

Question

This question is specifically about options in C++17. Assuming following declaration in C library (I cannot change them):

typedef enum {
    TYPEA = 0,
    TYPEB = 2,
    TYPEC = 4
} SPECIFIC_TYPE_t;

typedef struct {
    uint16_t Method : 1;
    uint16_t Access : 2;
    uint16_t VendorSpecific : 1;
    uint16_t Direction : 1;
    uint16_t Persistent : 1;
    uint16_t Internal : 4;
    uint16_t Reserved : 6;           
} PROPERTY_t;

typedef RESULT_t (*CB_DataPointRead_t) (void *Service, uint8_t Pinpoint, bool VendorSpecific,
                                        uint16_t GroupID, uint16_t ElementID, void *Data,
                                        uint8_t *DataLengthInOut);
typedef RESULT_t (*CB_DataPointWrite_t) (void *service, uint8_t Pinpoint, bool VendorSpecific,
                                         uint16_t GroupID, uint16_t ElementID, void *Data,
                                         uint8_t DataLength);

typedef struct {
    uint16_t GroupID;
    uint16_t ElementID;
    uint8_t Pinpoint;
    SPECIFIC_TYPE_t Type;
    uint8_t Size;
    PROPERTY_t Property;
    union {
        struct {
            CB_DataPointRead_t Read;
            CB_DataPointWrite_t Write;
        } Callback;
        struct {
            void *Data;
        } DirectAccess;
    } AccessType;
} DataPoint_t;

Status in pure C

To initialize the last element designator initializers work well in C:

uint16t dataPointValue = 0;
const DataPoint_t firstDatapointConfig = {
    /*...*/,
    .DirectAccess = { (void*)&dataPointValue; }
};

Designator initializers in C++

They appear in C++20 and aren't compatible with C in many aspects.

Problem

I'd like to initialize variable like firstDatapointConfig as const qualified in C++17. So far I don't see a way other than write a function in C (compiled as C code) and return the initialized structure to a variable before use. I tried various ways, including gnuc++17 which handles designator initializers, except it tells me:

error: 'const DataPoint_t' has no non-static data member named 'DirectAccess'

and MSVC don't digest this method of initialization at all without C++20 enabled.

Addressing the last element outside initializer, don't work either:

datapoint.DirectAccess = { &value };

results in the following error:

error: 'struct DataPoint_t' has no member named 'DirectAccess'

Comment

It was much easier to use these structures in Rust after processing them through bindgen :-)

Question

Is there a way to initialize the variable of DataPoint_t type in C++17 with DirectAccess element filled with the right value?

Answer 1

I'd like to initialize variable like firstDatapointConfig as const qualified in C++17

With all that C++ has to offer:

constexpr DataPoint_t create_DataPoint_t(uint16_t *v) {
    DataPoint_t r{};
    r.AccessType.DirectAccess.Data = v;
    return r;
}    
const DataPoint_t firstDatapointConfig = create_DataPoint_t(&dataPointValue);

with designated initializers:

const DataPoint_t firstDatapointConfig2 = {
    .AccessType = {
        .DirectAccess = {
            .Data = &dataPointValue
        }
    }
};

Addressing the last element outside initializer, don't work either:

datapoint.DirectAccess = { &value };

Because there is no such element, there is datapoint.AccessType.DirectAccess.Data.

To initialize the last element designator initializers work well in C:

uint16t dataPointValue = 0;
const DataPoint_t firstDatapointConfig = {
    /*...*/,
    .DirectAccess = { (void*)&dataPointValue; }
};

The presented code is invalid - uint16t is meant to be uint16_t and ; is a typo. And still after fixing the typos, no, the presented code is invalid in "pure C" and "does not work well" godbolt link. There is no such thing as DirectAccess in DataPoint_t - there is such member in the unnamed union declared inside DataPoint_t. You can do in C:

const DataPoint_t firstDatapointConfig3_in_C = {
    .AccessType = {
        .DirectAccess = { (void*)&dataPointValue }
    }
};

or

const DataPoint_t firstDatapointConfig4_in_C = {
    .AccessType.DirectAccess = { (void*)&dataPointValue }
};

or

const DataPoint_t firstDatapointConfig4_in_C = {
    .AccessType.DirectAccess.Data = (void*)&dataPointValue
};

The cast to void* is superfluous - all pointers are implicitly converted to void*. Note that the following:

const DataPoint_t firstDatapointConfig5_in_C = {
    .AccessType = { (void*)&dataPointValue }
};

would be equal to:

const DataPoint_t firstDatapointConfig6_in_C = {
    .AccessType.Callback.Read = (void*)&dataPointValue
};

Most probably you are coding under -fms-extensions with GNU gcc or with MSVC, in which case you should be aware that you are using an extension that imports unnamed structure members to parent structure. The code is invalid in "pure C", it's using an extension to C.

Answer 2

Is there a way to initialize the variable of DataPoint_t type in C++17 with DirectAccess element filled with the right value?

Yes, even though my way of doing it is a little cumbersome. There may be easier ways:

// Make a usable type of that anonymous entity:
using AccessType_t = decltype(DataPoint_t::AccessType);

// Use the new type and prepare what you need:
AccessType_t at;
at.DirectAccess.Data = nullptr;

// initialize your DataPoint_t
const DataPoint_t firstDatapointConfig{1,2,3,TYPEA,4, PROPERTY_t{}, at};

If you do this a lot you could make a helper function:

using AccessType_t = decltype(DataPoint_t::AccessType);
using Callback_t = decltype(AccessType_t::Callback);    
using DirectAccess_t = decltype(AccessType_t::DirectAccess);

template<class U>
constexpr auto init_AccessType(U u) {
    AccessType_t at;

    if constexpr (std::is_same_v<U,Callback_t>) {
        at.Callback = u;
    } else if constexpr (std::is_same_v<U,DirectAccess_t>) {
        at.DirectAccess = u;
    } else {
        // uninitialized
    }
    return at;
}

const DataPoint_t firstDatapointConfig{1,2,3,TYPEA,4, PROPERTY_t{},
                                       init_AccessType(DirectAccess_t{nullptr})};