C++ 如何使用模板方法避免循环依赖

所以，我一直在一个系统API项目中工作，我试图找出如何在静态模板方法的定义中避免循环依赖。问题是，模板方法不能在分离的cpp中定义，我也不能在头文件中定义它，因为这会导致循环依赖：

流程h：

#include "system.h"
#include "flowImpl.h" //circular dependency
#include <vector>
#ifndef TRAB_INDIVIDUAL_FLOW_H
#define TRAB_INDIVIDUAL_FLOW_H

typedef std::vector<System*>::iterator SystemIterator;

class Flow {
public:

    //-----------------------------------
    //What's giving me problems
    template <typename T_FLOW_IMPL>
    static Flow* createFlow() {
        return FlowImpl::createFlow<T_FLOW_IMPL>();
    }

    template <typename T_FLOW_IMPL>
    static Flow* createFlow(System* s1,System* s2,std::string str) {
        return FlowImpl::createFlow<T_FLOW_IMPL>(s1,s2,str);
    }
    //-----------------------------------

    virtual double executeFunction()=0;
    virtual System* getTargetSys()=0;
    virtual System* getSourceSys()=0;
    virtual std::string getName()=0;
    virtual void changeTargetSys(SystemIterator)=0;
    virtual void changeSourceSys(SystemIterator)=0;
    virtual void changeTargetSys(System*)=0;
    virtual void changeSourceSys(System*)=0;

};

#endif

#包括“system.h”
#包括“flowImpl.h”//circular dependency
#包括
#ifndef TRAB_单个流量
#定义交通流量
typedef std:：vector:：iterator SystemIterator；
类流{
公众：
//-----------------------------------
//什么给我带来了麻烦
模板
静态流*createFlow（）{
返回FlowImpl:：createFlow（）；
}
模板
静态流*createFlow（系统*s1，系统*s2，标准：：字符串str）{
返回FlowImpl:：createFlow（s1、s2、str）；
}
//-----------------------------------
虚拟双执行函数（）=0；
虚拟系统*getTargetSys（）=0；
虚拟系统*getSourceSys（）=0；
虚拟std:：string getName（）=0；
虚拟void changeTargetSys（SystemIterator）=0；
虚拟void changeSourceSys（SystemIterator）=0；
虚拟void changeTargetSys（系统*）=0；
虚拟void changeSourceSys（系统*）=0；
};
#恩迪夫

flowImpl.h

#include "flow.h"
#ifndef TRAB_INDIVIDUAL_FLOWIMPL_H
#define TRAB_INDIVIDUAL_FLOWIMPL_H

class ModelImpl;

class FlowImpl : public Flow {
    friend ModelImpl;
    friend Flow;

private:
    FlowImpl();
    FlowImpl(System*,System*,std::string);
    FlowImpl(Flow*,std::string);
    std::string name;
    System* source_sys;
    System* target_sys;

    template <typename T_FLOW_IMPL>
    static Flow* createFlow()  {
        Flow* f = new T_FLOW_IMPL();
        return f;
    }

    template <typename T_FLOW_IMPL>
    static Flow* createFlow(System*,System*,std::string)  {
        Flow* f = new T_FLOW_IMPL(s1,s2,str);
        return f;
    }

protected:
    double getSourceQ();
    double getTargetQ();

public:
    virtual ~FlowImpl();
    bool operator==(FlowImpl&);
    FlowImpl& operator=(const FlowImpl&);

    virtual double executeFunction()=0;
    System* getTargetSys() override;
    System* getSourceSys() override;
    std::string getName() override;
    void changeTargetSys(SystemIterator) override;
    void changeSourceSys(SystemIterator) override;
    void changeTargetSys(System*) override;
    void changeSourceSys(System*) override;
};

#endif

#包括“flow.h”
#ifndef TRAB_单个流程实施
#定义TRAB_单独的流程impl_H
类ModelImpl；
类FlowImpl：公共流{
朋友模型impl；
朋友流；
私人：
FlowImpl（）；
FlowImpl（系统*，系统*，标准：：字符串）；
FlowImpl（流*，标准：：字符串）；
std：：字符串名；
系统*源系统；
系统*目标系统；
模板
静态流*createFlow（）{
Flow*f=新的T_Flow_IMPL（）；
返回f；
}
模板
静态流*创建流（系统*，系统*，标准：：字符串）{
流量*f=新的T_流量（s1、s2、str）；
返回f；
}
受保护的：
双getSourceQ（）；
双getTargetQ（）；
公众：
虚拟~FlowImpl（）；
布尔运算符==（FlowImpl&）；
FlowImpl&运算符=（常量FlowImpl&）；
虚拟双执行函数（）=0；
系统*getTargetSys（）覆盖；
系统*getSourceSys（）覆盖；
std:：string getName（）覆盖；
无效changeTargetSys（系统迭代器）覆盖；
无效changeSourceSys（SystemIterator）覆盖；
无效更改目标系统（系统*）覆盖；
无效变更源系统（系统*）覆盖；
};
#恩迪夫

我尝试使用前向声明，但没有成功，因为我无法前向声明另一个类（FlowImpl:：createFlow（））的方法，只能声明整个类

我在这些静态方法中的目标是使用接口创建一个具有静态成员的方法工厂，因为我不能对静态模板方法使用“virtual”，所以我唯一的选择是在接口上实现它，并且在实现内部调用相同的静态方法，但子类具有要分配的属性。正如我所说的，我也不能这样做，因为模板方法不能在不同的文件中实现，如果我在头文件中定义它，它将导致循环依赖“flowImpl.h”

谢谢你的阅读！如有任何歧义或信息缺失，请报告，以便我澄清。

从

flow.h

中删除

\include

的

，并向前声明模板类方法：

class Flow {
public:

    // ...

    template <typename T_FLOW_IMPL>
    static Flow* createFlow();

对其他模板方法也执行同样的操作。请注意，需要调用这些类方法的任何内容都必须包含

flowImpl.h

头文件。

从

flow.h

中删除

#include

的

，并向前声明模板类方法：

class Flow {
public:

    // ...

    template <typename T_FLOW_IMPL>
    static Flow* createFlow();

对其他模板方法也执行同样的操作。注意，需要调用这些类方法的任何东西都必须包含

flowImpl.h

头文件