如何在类型定义中为结构成员分配预定义值？

Question

This is a long shot, but maybe there will be some ideas. On a system I programming, I have defined structures to program processor registers. The registers are comprised of several fields of a few bits each, with potentially "reserved" bits in between. When writing to a register, the reserved bits must be written as zeros.

For example:

typedef struct {
    uint32_t power    : 3;
    uint32_t reserved : 24;
    uint32_t speed    : 5;
} ctrl_t;

void set_ctrl()
{
    ctrl_t r = {
        .power    = 1;
        .speed    = 22;
        .reserved = 0;
    }

    uint32_t *addr = 0x12345678;

    *addr = *((uint32_t *) &r);

    return;
}

I want to be able to set the reserved field to a default value (0 in this example), and to spare the need for an explicit assignment (which happens a lot in our system).

Note that if the instantiated object is static, then by default an uninitialized field will be 0. However, in the above example there is no guarantee, and also I need to set any arbitrary value.

Answer 1

Structure type definitions in C cannot express values for structure members. There is no mechanism for it. Structure instance definitions can do.

I want to be able to set the reserved field to a default value (0 in this example), and to spare the need for an explicit assignment (which happens a lot in our system).

Note that if the instantiated object is static, then by default an uninitialized field will be 0. However, in the above example there is no guarantee, and also I need to set any arbitrary value.

That the default value you want is 0 is fortuitous. You seem to have a misunderstanding, though: you cannot partially initialize a C object. If you provide an initializer in your declaration of a structure object, then any members not explicitly initialized get the same value that they would do if the object had static storage duration and no initializer.

Thus, you can do this:

void set_ctrl() {
    ctrl_t r = {
        .power    = 1,
        .speed    = 22,
        // not needed:
        // .reserved = 0
    };

    // ...

If you want an easy way to initialize the whole structure with a set of default values, some non-zero, then you could consider writing a macro for the initializer:

#define CTRL_INITIALIZER { .power = 1, .speed = 22 }

// ...

void set_other_ctrl() {
    ctrl_t r = CTRL_INITIALIZER;
    // ...

Similarly, you can define a macro for partial content of an initializer:

#define CTRL_DEFAULTS .power = 1 /* no .speed = 22 */

// ...

void set_other_ctrl() {
    ctrl_t r = { CTRL_DEFAULTS, .speed = 22 };
    // ...

In this case you can even override the defaults:

    ctrl_t r = { CTRL_DEFAULTS, .power = 2, .speed = 22 };

... but it is important to remember to use only designated member initializers, as above, not undesignated values.

Answer 2

It can't be done.

Values don't have "constructors" in the C++ sense in C. There's no way to guarantee that arbitrary code is run whenever a value of a certain type is created, so this can't be done. In fact "creation" of a value is quite a lose concept in C.

Consider this:

char buf[sizeof (ctrl_t)];
ctrl_t * const my_ctrl = (ctrl_t *) buf;

In this code, the pointer assignment would have to also include code to set bits of buf to various defaults, in order for it to work like you want.

In C, "what you see is what you get" often holds and the generated code is typically quite predictable, or better due to optimizations. But that kind of "magic" side-effect is really not how C tends to work.

It is probably better to not expose the "raw" register, but instead abstract out the existance of reserved bits:

void set_ctrl(uint8_t power, uint8_t speed)
{
  const uint32_t reg = ((uint32_t) power << 29) | speed;
  *(uint32_t *) 0x12345678 = reg;
}

This explicitly computes reg in a way that sets the unused bits to 0. You might of course add asserts to make sure the 3- and 5-bit range limits are not exceeded.