Question

I’ve got some code originating from a DSL that needs to be translated for a C++ caller. I need to figure out how to sort #include dependencies in C++. Fortunately, I have a few restrictions that can make my task easier:

1. The result contains no templates or macros. I can use templates or macros to make my life easier, but the DSL doesn’t explicitly generate anything that requires them- all preprocessing, code generation is taken care of on that end.
2. The resulting code doesn’t have to be readable or maintainable at all- it’s going to be both produced and consumed by a program. Preferably it would not involve any performance penalties or confuse the optimizers, but I can live if it has to.

However, I have to convert some code that describes programs that are legal C++, but can never be defined, such as

struct X {
    Y y;
    Y func();
};
struct Y {
    X func();
};
// or
struct Y {
    void func(X x);
};
struct X {
    void func(Y y);
};

So far, I came up with the idea that I would make each type it’s own independent header, and then in the implementation file, I can just #include all the types the implementation depends on, which is not going to be too difficult. The issue is how I can mangle the code of X and Y so that this is possible.

Right now, I’ve thought of applying RVO and NRVO, and doing something somewhat similar for arguments. But, aren’t there cases where they’re not just not really optimizations, but not actually possible? This is written in MSVC10 so I can cope with any additional features C++0x has to offer here.

Edit: I edited my code, because I slightly understated my needs. RVO and NRVO also can’t cut this.

Edit edit: I guess that, if forward declarations will suffice for function return values and arguments, I could topologically sort for the include orders of data members. After all, it’s still not legal to do something like

struct X {
    Y y;
};
struct Y {
    X x;
};

Answer 1

Topological sort is the way to go.

If that doesn’t work, you need to transform your code using shared_ptr or something that relaxes the ordering constraints.