Circular dependency between struct and function in C

Question

I have the following files:

A.h

#ifndef __A_H_
#define __A_H_

#include <B.h> // contains foo_t
typedef struct {
     foo_t foo;
     ...
} baz_t;

#endif

B.h

#ifndef __B_H_
#define __B_H_

#include <A.h> // contains baz_t
typedef struct {
     ...
} foo_t;

extern int useful_func(baz_t d);

#endif

When I compile this B.h refuses to compile complaining error: unknown type name 'baz_t'

I am assuming this error is owing to circular dependency between the two files. But I am wondering how do I forward declare baz_t to solve this? I found answers relating to circular dependencies between structs. But I am unsure how I would solve this. I would appreciate some help here. I am looking for a strictly C99 solution.

EDIT

1. I previously forgot to mention this but I have already used include guards.
2. A very obvious solution as suggested by user KamilCuk is moving useful_func to A.h. This has also occured to me but software organization wise useful_func unfortunately belongs to B.h. This problem could be a reflection of a poor design as well.

Answer 1

You can use forward declaration as follows:

struct foo;

typedef struct {
    struct foo foo;
    ...
} baz_t;

And then use it normally on B.h

That said, circular dependencies can be avoided is you define everything on a third header that you use as interface. It would be cleaner, but it's not always possible.

Answer 2

Typically, one would pass pointers to structures rather than passing them by value. If that would be acceptable, things are easy, since C compilers will accept a declaration:

void doSomethingWithAFoo(struct foo *it);

without regard for whether they have seen any definition for struct foo. Indeed, compilers will even accept function definitions like:

void doSomethingWithAFooTwice(struct foo *it)
{
  doSomethingWithAFoo(it);
  doSomethingWithAFoo(it);
}

without having to know or care about whether, where, or how struct foo is defined.

Note that an advantage of using struct tag syntax rather than typedef names is that prototypes using the struct tag syntax don't require declaring or defining anything that can't be harmlessly redeclared arbitrarily many times.