Can anyone recommend a way to write a function that counts the number of fields in a struct? i.e. - pseudocode- 'for field in struct'

Question

I want a C function that I can pass a structure to and it will return the number of fields/members within the structure.

At the moment I've found the easiest way is to just make a table and add to the table anytime I add a struct to any of the programs.

I guess I'm experiencing an XY problem (per the suggestions) So anyway, the reason why I would have use for this type function is because I'm wanting to send structures over a socket and to avoid the whole serialization process the way in which i'm trying to do this is by adding delimiters to the structure's field members. Like this:

0x001 --> hdrdata --> 0x003 --> hdrdata --> 0x017 --> 0x002 --> bodydata --> 0x003 --> bodydata --> 0x003 --> bodydata --> 0x004

As you can see there may be 1 bodydata or there may be 10 bodydata etc. The only other thing I can quickly think to do is add a member to my structs that would inform my header how many 'bodydata' transmissions will be coming through so the client knows how many 0x003's to expect.

Or (and i'm not asking for an answer to this but feel free if you are so inclined) can anyone recommend a better protocol design for sending structures over socket in unix? Most of this project is for my own learning so i'm not interested in using an already complete library/package solution otherwise i'd just be writing this in another language in the first place.

Answer 1

This is very very ugly, but the only thing I can think of is an X-Macro:

#include <stdio.h>

#define MEMBERS \
    X(char a)   \
    X(float b)  \
    X(double c)

struct T {
#define X(x) x;
    MEMBERS
#undef X
};

int main(void)
{
    size_t n = 0
#define X(x) +1
    MEMBERS
#undef X
    ;

    printf("%zu members\n", n);
    return 0;
}

This expands to:

#include <stdio.h>

struct T {
    char a;
    float b;
    double c;
};

int main(void)
{
    size_t n = 0+1+1+1;

    printf("%zu members\n", n);
    return 0;
}

As pointed out by @HAL9000 in comments, you can generate both (the struct and the counter) at the same time in this way:

#include <stdio.h>

#define GENERATE_STRUCT(s) s;
#define GENERATE_SCOUNT(s) +1

#define set_struct(name)            \
struct name {                       \
    name##_members(GENERATE_STRUCT) \
};                                  \
                                    \
size_t name##_count(void)           \
{                                   \
    return 0                        \
    name##_members(GENERATE_SCOUNT) \
    ;                               \
}

#define foo_members(X)  \
    X(char a)           \
    X(float b)          \
    X(double c)

set_struct(foo)

int main(void)
{
    printf("%zu members\n", foo_count());
    return 0;
}

In this case is expanded to:

#include <stdio.h>

struct foo {
    char a;
    float b;
    double c;
};

size_t foo_count(void)
{
    return 0+1+1+1;
}

int main(void)
{
    printf("%zu members\n", foo_count());
    return 0;
}

Finally, another implementation provided by @Lundin using an enum instead of a variable:

#include <stdio.h>

#define MEMBERS       \
/*    type    name */ \
    X(char,   a)      \
    X(float,  b)      \
    X(double, c)      \

struct T {
  #define X(type, name) type name;
    MEMBERS
  #undef X
};

enum
{
  #define X(type, name) dummy_##name,
    MEMBERS
  #undef X
  MEMBER_COUNT
};

int main(void)
{
    printf("%d members\n", MEMBER_COUNT);
    return 0;
}

Expands to:

#include <stdio.h>

struct T {
    char a;
    float b;
    double c;
};

enum {
    dummy_a,
    dummy_b,
    dummy_c,
    MEMBER_COUNT
};

int main(void)
{
    printf("%d members\n", MEMBER_COUNT);
    return 0;
}