How to avoid circular dependency with template method - c++

Question

So, i've been working in a project of a System API, and i'm trying to figure out how to avoid circular dependency in the definition of a static template method. The thing is, template methods cannot be defined in a separeted cpp, and i cannot define it in the header file either because that would cause circular dependency:
flow.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
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
I tried using forward declaration, but with no success, because i cannot forward declare a method of another class (being FlowImpl::createFlow()), only the entire class.
My objective in those static methods are to make a Method Factory with static members using interfaces, and since i cannot use "virtual" for static template methods, my only option was to implement it on the interface, and inside the implementation call the same static method but for the subclass, which have the atributes for allocation. As I said, I cannot do that either because template methods can't be implemented in a different file, and if I define it inside the header it will cause circular dependency with "flowImpl.h".
Thanks for reading! Any ambiguities or lack of information please report so i can clarify it.

Answer 1

Remove the #include of flowImpl.h from flow.h, and forward-declare the template class method:
class Flow {
public:
// ...
template <typename T_FLOW_IMPL>
static Flow* createFlow();
Then finish the job in flowImpl.h, after the implementation class's declaration:
class flowImpl {
// ...
};
template <typename T_FLOW_IMPL>
static Flow* Flow::createFlow() {
return FlowImpl::createFlow<T_FLOW_IMPL>();
}
Do the same for the other template method, as well. Note that whatever needs to call these class methods will have to include the flowImpl.h header file, though.