模板类中的循环依赖

Question

I have a circular dependency simplified to the following:

// Bar.h
struct Bar {};

// Base.h
#include "Foo.h"
struct Bar;
struct Base {
    void func(std::shared_ptr<Foo<Bar>> foobar); // use methods of Foo in some way.
};

// Derived.h
#include "Base.h"
struct Derived : public Base {};

// Foo.h
#include "Derived.h"
template <typename T>
struct Foo {
    void func(std::shared_ptr<Derived> d) {
        // use methods of Derived in some way.
    }
};

I can't simply forward declare Foo in Base.h as it is a template class, can't forward declare Base in Derived.h due to the polymorphism, and can't forward declare Derived in Foo.h because Foo::func uses members of Derived .

I've read before about separating template implementation from the declaration thought I'm unaware of best practices and unsure if it would work in this case. The two, Derived and Foo are used widely throughout my program.

How can I resolve this dependency?

Answer 1

Declaring a function taking a std::shared_ptr<type> doesn't require a full definition of type , all that is needed is a (forward) declaration. This allows you to avoid #include of Derived.h (in Foo.h) and/or of Foo.h (in Base.h)

Answer 2

Enable inline functions in classes referencing each other:

header Ah

struct B;
struct A { 
    void a() {}
    void f();
    std::shared_ptr<B> b;
};
#include "A.tcc"

header A.tcc

#include B.h
inline void A::f() { b->b(); }

header Bh

struct A;
struct B { 
    void b() {}
    void f();
    std::shared_ptr<A> a;
};
#include "B.tcc"

header B.tcc

#include A.h
inline void B::f() { a->a(); }

Please ensure all files have header guards!