远期申报C

Question

I have 2 header files api.h and impl.h

api.h is visible to outside files and will be included in other ".c" files. So api.h includes impl.h

api.h defines 2 structures

typedef struct
    {
    uint32_t att;
    union
    {
        struct
        { 
            void* buffer;
            size_t length;
        } x;  
        struct
        {
            int a, b;
        } v;
    } content;
}dummy;

and impl.h has some other structures and function def which uses this structure. I tried forward declaration but it doesn't help me .

Please help .

Answer 1

Actually, your dummy is not a structure, but a typedef to an unnamed structure. Try naming the structure, you can then forward-declare it:

typedef struct sdummy dummy; // forward declaration

void foo(dummy *);

struct sdummy { ... }; // definition

Answer 2

Either reorder your code in api.h so the type declaration precedes the #include "impl.h" or give your (currently anonymous) structure itself a name like dummy , dummy_ , dummy_s so you can add a forward declaration

typedef struct dummy_ dummy;

to impl.h .

Answer 3

If you want to hide the details of your struct then you have to define it in some .c file, let's say impl.c , so that it has internal linkage to that compilation unit. To use it you have to expose create, destroy, getter and setter functions. So a basic setup would look like this:

api.h with forward declaration for your struct

// forward declaration
typedef struct dummy* dummy_t;

// create / destroy / setter / getter (omitted)
dummy_t alloc_dummy();
void free_dummy(dummy_t);
void set_number(dummy_t, int);
void set_string(dummy_t, char*);
void print_dummy(dummy_t);

Then comes impl.c

#include "api.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

struct dummy {
    int n;
    char* s;
};

dummy_t alloc_dummy()
{
    return malloc(sizeof(struct dummy));
}

void free_dummy(dummy_t dummy)
{
    if(dummy) {
        free(dummy->s);
        free(dummy);
    }
}

void set_number(dummy_t dummy, int n)
{
    if(dummy) {
        dummy->n = n;
    }
}

void set_string(dummy_t dummy, char* s)
{
    if(dummy && s) {
        dummy->s = strdup(s);
    }
}

void print_dummy(dummy_t dummy)
{
    if(dummy) {
        printf("%d, %s\n", dummy->n, dummy->s);
    }
}

And finally the usage in some other C files, here main.c

#include "api.h"

int main(int argc, char** argv) 
{
    // struct dummy d; // error! type is unknown
    // instead use the create function
    dummy_t d = alloc_dummy();
    // d->n = 1; // error! dereference of unknown type
    // instead use the setter function
    set_number(d, 1);
    set_string(d, "Hello, world!");
    print_dummy(d);
    free_dummy(d);
    return 0;
}

Ouput

1, Hello, world!