How to create derived structure properties in C

Question

In Python, its possible to create a derived property from a class using the @property decorator for example

class State():
    def __init__(self, fav_num_monday, fav_num_not_monday, is_monday):
        self.fav_num_monday = fav_num_monday
        self.fav_num_not_monday = fav_num_not_monday
        self.is_monday = is_monday

    @property
    def fav_num(self):
        return self.is_monday * self.fav_num_monday + \
            (1 - self.is_monday) * self.fav_num_not_monday

state = State(12, 5, 0)
print("Current favourite number: %d" % state.fav_num)

My question is then what is the best way to achieve this in C (where speed is of the utmost importance). I've have added below some ways I have tried but am not sure if they could have repercussions in a larger codebase. They are as follows:

1. Simply writing out the whole expression each time. Pros: No unexpected repercussions, no code/speed penalty. Cons: Ugly code, takes a long time to write.
2. Using a get function. Pros: Code easier to read. Cons: Inefficient code (slower than 1).
3. Defining a macro. Pros: No code/speed penalty. Code quick to write. Cons: Potential repercussions later, code not so easy to follow.

The example program is below

#include <stdio.h>
#include <string.h>

#define state_fav_num  state.is_monday * state.fav_num_monday + (1 - state.is_monday) * state.fav_num_not_monday

struct State {
    int fav_num_monday;
    int fav_num_not_monday;
    int is_monday;
};

int get_state(struct State *state, char *property) {
    // Returns value of the property in state. 
    // Allows us to create derived properties also.
    if (!strncmp(property, "fav_num_monday", 14)) {
        return state->fav_num_monday;
    } else if (!strncmp(property, "fav_num_not_monday", 18)) {
        return state->fav_num_not_monday;
    } else if (!strncmp(property, "is_monday", 9)) {
        return state->is_monday;
    } else if (!strncmp(property, "fav_num", 7)) {
        return state->is_monday * state->fav_num_monday +
            (1 - state->is_monday) * state->fav_num_not_monday;
    }
}

int main() {
    // Set the state.
    struct State state;
    state.fav_num_monday = 12;
    state.fav_num_not_monday = 5;
    state.is_monday = 1;

    // Print favourite number in different ways.
    printf("\n1) Current favourite number is %d.",
        state.is_monday * state.fav_num_monday +
        (1 - state.is_monday) * state.fav_num_not_monday);

    printf("\n2) Current favourite number is %d.",
        get_state(&state, "fav_num"));

    printf("\n3) Current favourite number is %d.",
        state_fav_num);

    printf("\n");

    return 0;
}

Answer 1

You can get the best of both worlds (function and macro) for readability and performance, with a static inline function.

You usually wouldn't use that, but if you know the compiler is going to optimize its code away, then it's OK to use it. The usual rule I use is 3 or less lines of code, and the function should require extra performance.

That said, your get_state doesn't meet the (my) requirements for a static inline function, but if you only want a function to get only the fav_num, it would make sense:

struct State {
    int     fav_num_monday;
    int     fav_num_not_monday;
    bool    is_monday;
};


static inline   int get_fav_num(const struct State *state)
{

    if (state->is_monday)
        return  state->fav_num_monday;
    else
        return  state->fav_num_not_monday;
}


int main(void)
{
    struct State state;
    int fav_num;

    state   = (struct State){
        .fav_num_monday     = 12;
        .fav_num_not_monday = 5;
        .is_monday          = 1;
    };

    // Print favourite number in different ways.
    printf("\n");
    if (state.is_monday)
        fav_num = state->fav_num_monday;
    else
        fav_num = state->fav_num_not_monday;
    printf("1) Current favourite number is %d.\n", fav_num);

    fav_num = get_fav_num(&state);
    printf("4) Current favourite number is %d.\n", fav_num);

    return 0;
}

Disclaimer: This code needs C99 or later.

Although here the code is all together, the struct State {...}; and the static inline function would usually go in a header .h file.

Also, I would improve your get_state function in this way:

enum Properties {
    FAV_NUM_MONDAY,
    FAV_NUM_NOT_MONDAY,
    IS_MONDAY,
    FAV_NUM
};

int get_state(const struct State *state, int property)
{

    switch (property) {
    case FAV_NUM_MONDAY:
        return  state->fav_num_monday;
    case FAV_NUM_NOT_MONDAY:
        return  state->fav_num_not_monday;
    case IS_MONDAY:
        return  state->is_monday;
    case FAV_NUM:
        return  get_fav_num(state);
    default:
        return -1;  /* Error */
    }
}

This function would be a usual extern function and would go in a .c file, although the enum Properties should go in a header file so that it can be used by the user of the function.

Edit: Add high performance version using array

state.h

#include <stdint.h>

enum    State_Properties {
    FAV_NUM_MONDAY,
    FAV_NUM_NOT_MONDAY,
    IS_MONDAY,
    STATE_PROPERTIES
};


static inline
uint_fast8_t get_fav_num(const uint_fast8_t *restrict (state[STATE_PROPERTIES]))
{

    if ((*state)[IS_MONDAY])
        return  (*state)[FAV_NUM_MONDAY];
    else
        return  (*state)[FAV_NUM_NOT_MONDAY];
}

main.c

#include <inttypes.h>

#include "state.h"

int main(void)
{
    uint_fast8_t    state[STATE_PROPERTIES];
    uint_fast8_t    fav_num;
    uint_fast8_t    fav_num_monday;

    state   = (uint_fast8_t [STATE_PROPERTIES]){
        [FAV_NUM_MONDAY]        = 12;
        [FAV_NUM_NOT_MONDAY]    = 5;
        [IS_MONDAY]             = true;
    };

    // Print favourite number in different ways.
    fav_num = get_fav_num(&state);
    printf("5) Current favourite number is %"PRIuFAST8".\n", fav_num);

    // Example of how to retrieve any property:
    fav_num_monday  = state[FAV_NUM_MONDAY];
}

Of course you can change the type to anyone you want. I used uint_fast8_t, because your data can fit in there, and it is the fastest type on any system.