解决循环依赖

Question

我知道有几个循环依赖问题，但我就是解决不了这个问题。

我有两个类：Manager和Managed。Manager创建Managed对象，Managed基本上包装了几个Manager方法，其中一些方法是模板化的。

// Manager.h
struct Manager {

    Managed create(); // To be defined in the .cpp
    
    template <typename T>
    Managed create() {
        Managed managed(this); // Access Managed constructor
        managed.whatever<T>(); // Access templated function
        managed.whateverElse();
        return managed;
    }   
}

struct Managed {
    explicit Managed(Manager* manager) : manager(manager) {}
    
    template <typename T>
    void whatever() {
        manager->... // use the Manager pointer for whatever purpose
    }
    
    void whateverElse(); // To be defined in the .cpp

    Manager* manager;
}

无论如何，它都是一个静态库项目。

此外，可以在here中找到真正的代码。

有什么办法可以解决这个问题吗？

Answer 1

我只是重新排序您的代码并使用PIMPL，然后我构建了一个小示例：

#include <iostream>

struct Managed;
struct Manager;

struct Managed {
    explicit Managed(Manager* manager) : manager(manager) {}

    template <typename T>
    void whatever() { }

    void whateverElse(); // To be defined in the .cpp

    Manager* manager;
};


struct Manager {

    Managed create(); // To be defined in the .cpp

    template <typename T>
    Managed* create() {
        Managed* m = new Managed(this);// Access Managed constructor
        m->whatever<T>(); // Access templated function
        m->whateverElse();
        return m;
    }
};

它可以这样编译。但在任何情况下，都应该更好地考虑这种设计。

Answer 2

在处理依赖项时，首先要更改的是将所有实现移到所有声明之后，但要在类中实现方法。相反，在Managed类之后执行实现。

下一步是提供所有类的正向声明。例如，开始于

struct Managed;
struct Manager;

我将引用Johns的答案来提供更多的代码细节。

(当约翰意识到我想把我的评论变成一条评论时，他很友好地删除了他的回答。谢谢。我明确地引用，因为我看起来像是在隐式地这样做，编写了非常相似的代码。)John亲切地表示，编译这一点是可能的。

struct Managed;

struct Manager {

    Managed create(); // To be defined in the .cpp
    
    template <typename T>
    Managed create();
};

struct Managed {
    explicit Managed(Manager* manager) : manager(manager) {}
    
    template <typename T>
    void whatever();
    
    void whateverElse(); // To be defined in the .cpp

    Manager* manager;
};

template <typename T>
Managed Manager::create() {
    Managed managed(this); // Access Managed constructor
    managed.whatever<T>(); // Access templated function
    managed.whateverElse();
    return managed;
}   

template <typename T>
void Managed::whatever() {
    manager->create();
}