Efficient storage of parameters in C [closed] - c

Question

Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 4 years ago.
Improve this question
I have an application where I need to store values, those values can be either a double, an integer, a string (fixed size char array), uint8_t, chars, ...
Each of these values also has additional parameters, it can be Read-Only, Read-Write or they can have a max or min value (obviously for numeric types only).
So basically a simple struct would look like this:
typedef struct {
uint32_t current_val;
uint32_t min;
uint32_t max;
uint8_t type;
uint32_t initial_value;
uint8_t access_mode = READ_WRITE;
} valueType;
Now obviously this struct could only hold a uint32_t parameter value. I'd like to have many of those with different types and then store them in a common array.
Do you see any chance of doing this except for storing the reference to the instance and then finding out what the parameter type actually is?
I've seen a solution where for each of those parameters a memory section was allocated and then parameter was stored there. So basically the largest parameter was a 32byte string which caused even an uint32_t to occupy 32 bytes.
What would be the correct way to address this issue? Is there some common way to do this? Maybe just throw in some term so I know what to google for.

Answer 1

Efficient storage of parameters in C
Let us assume a fixed size per parameter.
So basically the largest parameter was a 32byte string
So we need at least 32 bytes. Use a union to overlay the various types of data.
typedef union {
char s[32];
TBD;
} valueType;
A string always ends with a null character so code can use the last char string[32-1] zero-ness as a flag for string vs. non-string.
For other types, keep track via a .type_identifier member.
typedef union {
char string[32];
struct {
union {
struct { uint32_t val; uint32_t min; uint32_t max; uint32_t initial; } t_uint32;
struct { float val; float min; float max; float initial; } t_float;
struct { char val; char min; char max; char initial; } t_char;
} u;
uint8_t type_identifier;
uint8_t access_mode;
} not_string;
} valueType;
This is fine when the size of .not_string is less than the size of .string.
Yet OP wants to code double, which commonly takes 8 bytes each and also wants 4 doublemembers.
So might as well:
typedef struct {
int type_identifier; // or uint8_t
int access_mode; // or uint8_t
union {
char string[32];
struct { uint32_t val; uint32_t min; uint32_t max; uint32_t initial; } t_uint32;
struct { double val; double min; double max; double initial; } t_double;
struct { float val; float min; float max; float initial; } t_float;
struct { char val; char min; char max; char initial; } t_char;
} u;
} valueType;
This may be as small as 2 + 32 bytes or a tad larger depending on padding requirements.

Answer 2

Unions are the way to go! Have an enum saying what type is stored there (I've used an int_8 to make the example small) and then do this:
struct {
int_8 type;
union {
int_8 eight_wide_thing;
char char_buffer[42];
double more_bad_variable_names;
}
int_32 foo_count;
} example;
You can do this:
struct example bar;
bar.eight_wide_thing = 42;
printf("%d", bar.eight_wide_thing);
bar.char_buffer[3] = '\0';
bar.char_buffer[0] = 'H';
bar.char_buffer[1] = 'i';
bar.char_buffer[2] = '!';
printf("%s", bar.char_buffer);
But not this:
bar.eight_wide_thing = 42;
bar.more_bad_variable_names /= 6;