如何在函数中捕获结构声明

Question

I have the following c code:

struct {
    short s;
    int n;
} variableName;

I want to write a function to capture this variable like so

void func(MyStruct* var){
    //do stuff
}

func(&variableName);

I would like to do this without providing a definition for the struct. Is there a way to capture variableName?

Answer 1

No, you can't pass an "anonymous" struct into a function in C. You could of course define your function to accept the arguments individually:

void func(short s, int n) { ... }

Or you can define the MyStruct structure in a place that both the function and the calling code has visibility to. Note that the whole struct is passed by value (copy) when you do that, which may be the behavior you want here (or may not be).

You may be looking for something more like a "dictionary" or "associative array" or "hash" type that many other languages provide, with arbitrary key value pairs in it. Pure C does not have a facility for this; the compiler wants to know the layout of a structure in advance.

(I'm not sure if you might be asking about a slightly more esoteric idea, which is hiding the composition of a structure and passing around an "opaque handle" out of and into an API. There are ways to structure that in C, but please say so if that's what you're talking about.)

Answer 2

Completely overlooked "I would like to do this without providing a definition for the struct. Is there a way to capture variableName?" in the OP, unless it was edited after. The question makes less sense now, but heres how you could normally pass a struct to a function for future readers.

#include <stdio.h>

    struct StructName{
        short s;
        int n;
    };

    void func(struct StructName struct_var){
            printf("Param values are: %4X %4X\n", struct_var.s & 0xFFFF, struct_var.n & 0xFFFF);
        }

    int main(){
        struct StructName struct_var;
        struct_var.s = 0xDEAD;
        struct_var.n = 0xBEEF;
        func(struct_var);
    }

//It looks like you are trying to use the definition as a variable. Here the definition is StructName and the variable is struct_var.

this sample code outputs: Param values are: DEAD BEEF

Answer 3

If you use clang or gcc, you may be able to use typeof :

struct foo {
    struct {
        int i;
    } anon;
} foo;

void do_something(typeof(foo.anon)* member) {
    member->i = 1;
}

If there is no global instance of your type, you may be able to use typeof((struct foo){}.anon) .

This comes with a lot of downsides. The most obvious ones are that:

• it's not standard, and it ties you to clang/gcc
• it's pretty darn ugly
• it might not behave as you expect anyway

For instance, structurally-equivalent anonymous types do not have the same type, so in something like this:

struct foo {
    struct {
        int i;
    } anon1;
    struct {
        int i;
    } anon2;
} foo;

anon1 and anon2 both have a different type, meaning that typeof one of them cannot be used to refer to both.

In the long run, you will almost certainly find that it's worth naming the structures, especially if you use them as function arguments. For instance, if you want to make your variable available from a header, I think that you'll have to work pretty hard to keep it anonymous.

Although it's not particularly pretty and not compatible with C++, C puts the name of nested declarations in the global namespace, so this is portable and it's not a very big code change to front-load:

struct {
    struct not_anon {
        int i;
    } anon;
} foo;

void do_something(struct not_anon* member) {
    member->i = 1;
}