Circular Dependency Solution - C

If I understood your question correctly, you have something like this:

derpfoo.h:

#ifndef DERPFOO_H
#define DERPFOO_H

#include "derpbar.h"

typedef struct {
        char *nothing;
} FOO;

BAR foo (BAR derp) {
        return derp;
}

#endif

      

        
        
        
      

    

derpbar.h:

#ifndef DERPBAR_H
#define DERPBAR_H

#include "derpfoo.h"

typedef struct {
        char *nothing;
} BAR;

FOO bar (FOO derp) {
        return derp;
}

#endif

      

        
        
        
      

    

and then a simple derp.c:

#include "derpfoo.h"
#include "derpbar.h"

int main (void) {
        return 0;
}

      

        
        
        
      

    

One of my friends introduced this issue to me in some SDL code a while ago and it took me a while to figure out why he does what he does and how to fix it intelligently.

The purpose of splitting code like this is that derpfoo and derpbar are logically separate, but they are also, unfortunately, interdependent. The simplest solution I found is to combine them and separate them by anatomy, not logic:

derpstructs.h:

#ifndef DERPSTRUCTS_H
#define DERPSTRUCTS_H

typedef struct {
        char *nothing;
} FOO;

typedef struct {
        char *nothing;
} BAR;

#include "derpfunctions.h"

#endif

      

        
        
        
      

    

derpfunctions.h:

#ifndef DERPFUNCTIONS_H
#define DERPFUNCTIONS_H

#include "derpstructs.h"

BAR foo (BAR derp) {
        return derp;
}

FOO bar (FOO derp) {
        return derp;
}

#endif

      

        
        
        
      

    

and still a simple derp.c:

#include "derpstructs.h"
#include "derpfunctions.h"

int main (void) {
        return 0;
}

      

        
        
        
      

    

Note that derpstructs.h includes derpfunctions.h at the end, not at the beginning. This is not, strictly speaking, necessary, but if you intend to include them within each other, you must include function definitions after defining the structures on which they depend in all possible inclusion paths. Moving on ...

This solution works, but it doesn't exactly match the original philosophy, which started the problem with the fact that the two parts are logically separate and should be kept in code.

The answer to both is to separate everything further and further customize the inclusion paths.

derpfoostructs.h includes derpbarstructs.h first and then defines a FOO structure and then optionally includes derpfoofunctions.h and derpbarfunctions.h at the end.

derpbarstructs.h includes derpfoostructs.h first and then defines a struct BAR and then optionally includes derpfoofunctions.h and derpbarfunctions.h at the end.

derpfoofunctions.h includes derpfoostructs.h and derpbarstructs.h first, then includes derpbarfunctions.h, and then defines its functions.

derpbarfunctions.h includes derpfoostructs.h and derpbarstructs.h first, then includes derpfoofunctions.h, and then defines its functions.

derp.c includes derpfoostructs.h and derpbarstructs.h and then includes derpfoofunctions.h and derpbarfunctions.h and then continues to do whatever it needs to do.

This satisfies both of the desired requirements. It removes circular dependencies and still maintains a logical separation of two logically separate blocks of code. You get two files to edit when moving from project to project instead of one, but it at least keeps the modified code separate from the immutable one. This, and this is the only solution I have found.

Hope this helped. Good luck with your projects.