Function to look though any struct in C - c

Question

I have a struct with variety of data types. I want to create a universal function
that can:
look through any struct and check if the item values are within
certain range for given types: (E.G. item 1 should be within 10~35,
item 3 should be either 0/1). Note that the struct's item types and
names are not passed to the function, just the struct(any struct)
Count how many items are in the struct given any structure
Example:
typedef struct _anyStruct_t
{
uint8_t item1;
uint16_t item2;
bool item3;
char item4;
}anyStruct_t

Answer 1

What you are asking for is effectively impossible in C.
First of all, struct types contain no metadata about their contents. At runtime, a struct object is just a sludge of bytes. There's no way to determine at runtime the number or types of members in a struct object.
Secondly, if you want to do this for any struct type, you will have to pass its address to the function as a void *, meaning you have no way of knowing whether it's a struct type at all.
You would basically have to create your own "class" type that a) stores metadata about its members and b) supports some form of inheritance such that you can pass a pointer to the base "class" type and use that to access the metadata and members.
IOW, you'd have to re-implement a good chunk of C++.
Edit
Actually, as Andrew mentions below, even C++ doesn't support reflection. You'd have to go even further.

Answer 2

As others have said, C doesn't support reflection and so there is no universal way to figure out what attributes exist in C data structure.
In the past I've seen folks write a meta-compiler which from some description language can be taught to generate C data structures and accessor methods.
Usually this is done if you're trying to write code that will iterate over and fill in data structures without needing to know all the details of the structures being processed - this can be useful in building messaging frameworks. But always feels cumbersome because some of your source code files are generated at build time (think lex and yacc).
Of course the other application for something like this is gdb. In that case the compiler, given '-g', generates the metadata about the data structures and embeds that in it the stabs (or gstabs, or some other) information in the object file. Your program could use /proc/self/ to find its object code on disk, open it and process through all of the stabs info. While clever, that would be very platform specific and probably pretty brittle.

Answer 3

look through any struct and check if the item values are within certain range for given types: (E.G. item 1 should be within 10~35, item 3 should be either 0/1). Note that the struct's item types and names are not passed to the function, just the struct(any struct)
This is not possible in C. If you only have a pointer to an unknown struct, there is no way to find out which fields the struct has.

Answer 4

As mentioned, one needs more information about what is in the struct. C, as opposed to C++, etc, wasn't designed around this abstraction. However, it's not impossible; nothing is stopping one from defining one's own virtual table.
#include <stdlib.h> /* EXIT rand */
#include <string.h> /* strcpy */
#include <stdio.h> /* sprintf, printf */
#include <assert.h> /* assert */
#include <stdint.h> /* (C99) uint8_t uint16_t */
#include <stdbool.h> /* (C99) bool */
union AllTypes {
bool boolean;
char letter;
uint8_t byte;
uint16_t word;
};
/* `is_valid` functions. */
static bool is_valid_boolean(const union AllTypes all) {
/* Not sure this will ever be false. */
return all.boolean == true || all.boolean == false;
}
static bool is_valid_letter(const union AllTypes all) {
return (all.letter >= 'a' && all.letter <= 'z')
|| (all.letter >= 'A' && all.letter <= 'Z');
}
static bool is_valid_byte(const union AllTypes all) {
return all.byte <= 35 && all.byte >= 10;
}
static bool is_valid_word(const union AllTypes all) {
return all.word < 1000;
}
/* `to_string` functions */
static void boolean_to_string(const union AllTypes all, char (*const a)[12]) {
strcpy(*a, all.boolean ? "true" : "false");
}
static void letter_to_string(const union AllTypes all, char (*const a)[12]) {
sprintf(*a, "'%c'", all.letter);
}
static void byte_to_string(const union AllTypes all, char (*const a)[12]) {
sprintf(*a, "b%u", all.byte);
}
static void word_to_string(const union AllTypes all, char (*const a)[12]) {
sprintf(*a, "w%u", all.word);
}
typedef void (*ToString)(const union AllTypes all, char (*const a)[12]);
/* The virtual-table. */
static const struct VTable {
ToString to_string;
bool (*is_valid)(const union AllTypes);
} vt_boolean = { &boolean_to_string, &is_valid_boolean },
vt_letter = { &letter_to_string, &is_valid_letter },
vt_byte = { &byte_to_string, &is_valid_byte },
vt_word = { &word_to_string, &is_valid_word };
/* The data has an extra `vt`; this would be implicit in C++. */
struct Data {
const struct VTable *vt;
union AllTypes all;
};
static void to_string(const struct Data *const data, char (*const a)[12]) {
data->vt->to_string(data->all, a);
}
static bool is_valid(const struct Data *const data) {
return data->vt->is_valid(data->all);
}
/* Testing. */
static void fill(struct Data *const data) {
assert(data);
switch(rand() / (RAND_MAX / 4 + 1)) {
case 0: data->vt = &vt_boolean;
data->all.boolean = rand() / (RAND_MAX / 2); break;
case 1: data->vt = &vt_letter;
data->all.letter = rand() / (RAND_MAX / 26 + 1) + 'a'; break;
case 2: data->vt = &vt_byte;
data->all.byte = rand() / (RAND_MAX / 25 + 1) + 10; break;
case 3: data->vt = &vt_word;
data->all.word = rand() / (RAND_MAX / 999 + 1); break;
}
}
int main(void) {
struct Data data[32], *d, *const d_end = data + sizeof data / sizeof *data;
char a[12];
/* Fill the data with random values. */
for(d = data; d < d_end; d++) {
fill(d);
if(!is_valid(d)) return fprintf(stderr, "Impossible!\n"), assert(0),
EXIT_FAILURE;
}
/* Print. */
fputs("{ ", stdout);
for(d = data; d < d_end; d++) {
if(d != data) fputs(", ", stdout);
to_string(d, &a);
fputs(a, stdout);
}
fputs(" }.\n", stdout);
return EXIT_SUCCESS;
}
Prints out on my machine,
{ false, w458, b15, true, b33, 'n', w34, true, b10, 'b', 'r', b33,
w526, true, 's', w761, 'b', b18, b28, w364, true, b28, b11, b32, 'l',
w477, false, 'e', 'x', w60, w504, b17 }.