模板化子类的工厂 [重复]

Question

我正在尝试使用类继承和工厂方法。

基本结构是我有一个基类Base，和一个派生类Child。

ChildFactory 方法允许人们选择Child 的不同实现，它们仍然提供相同的接口。

我所有的类都是模板，因为会有一些参数可以是floats 或ints 或其他。

但是，我在让所有模板很好地协同工作时遇到了一些麻烦。我得到的错误是关于未知的模板名称

如果我的解释有点不妥，我有一个 MWE 应该可以帮助您了解我在说什么（对此表示建设性的批评！）

├── child.h
├── child_impl.h
└── main.cpp

主文件

#include "child.h"
#include <iostream>

int main()
{
    mwe::Child<float> *child_0;
    mwe::Child<float> *child_1;
    mwe::ChildFactory<float> = child_factory;

    int input_param_1 = 5;
    child_0 = child_factory.get_child(1, input_param_1);
    child_1 = child_factory.get_child(2, input_param_1);
    std::cout << child_0->method1() << "\n";
    std::cout << child_1->method1() << "\n";
    return 0;
}

child.h

#ifndef CHILD_H
#define CHILD_H

#include "child_impl.h"
#include <stdexcept>
#include <iostream>

namespace mwe
{
template<typename T>
    class Base
    {
    public:
        Base(){};
        virtual int method1() = 0;
        virtual T method2() const = 0;

    };

template<typename T>
    class Child : public Base<T>
    {
        public:
            Child(int input_param_1)
                : Base<T>(),
                input_param_1(input_param_1){};

            virtual int method1() = 0;
            virtual T method2() const = 0;

            protected:
           int input_param_1;
     };

template<typename T>
    class ChildFactory
    {
    private:
      Child<T> * _child;
    public:
      Child<T> * get_child(int choice,
                       int input_param_1)
      {
      switch(choice)
        {
        case 1:
          _child = new Child_Imp_0<T>(input_param_1);
        case 2:
          _child = new Child_Imp_1<T>(input_param_1);

        default:
          throw std::invalid_argument("recieved in valid layer type");
        }
      return _child;
    }
};

};
#endif //CHILD_H

child_impl.h

#ifndef CHILD_IMPL_H
#define CHILD_IMPL_H

#include "child.h"

namespace mwe
{
    template<typename T>
    class Child_Imp_0 : public Child<T>
    {
    public:
    Child_Imp_0(int input_param_1)
: Child<T>(input_param_1),
    input_param_2(10 * input_param_1)
      {};

  int method1()
  {
    return 0;
  };

  T method2() const
  {
    return 0;
  };

protected:
  int input_param_2;
};

  template<typename T>
class Child_Imp_1 : public Child<T>
{
public:
Child_Imp_1(int input_param_1)
  : Child<T>(input_param_1),
    input_param_2(100 * input_param_1)
      {};

  int method1()
  {
    return 1;
  };

  T method2() const
  {
    return 0;
  };

protected:
  int input_param_2;
};
}
#endif //CHILD_IMPL_H

有没有想过如何让它发挥作用？

我一直在寻找相关问题，但到目前为止无济于事。 This question 和 this 以及其他一些是相关的。然而，他们似乎正在处理我难以应用于我的问题的其他复杂性。

或者，是否有任何替代设计可以提供相同的功能？

Answer 1

这是编译器生成的错误非常无用的罕见情况之一。

这是因为您的代码问题发生在预处理期间，甚至在编译器有机会开始解释代码之前。

具体来说，让我们看看child.h 将#include child_impl.h 替换为文件内容时的样子（毕竟#include 所做的一切）：

#ifndef CHILD_H
#define CHILD_H

#ifndef CHILD_IMPL_H
#define CHILD_IMPL_H

#include "child.h"

namespace mwe
{
   template<typename T>
   class Child_Imp_0 : public Child<T> 
   { ... };
}
#endif 

#include <stdexcept>
#include <iostream>

namespace mwe
{
  ...
}
#endif

现在，如果我们扩展 #include child.h:

#ifndef CHILD_H
#define CHILD_H

#ifndef CHILD_IMPL_H
#define CHILD_IMPL_H

#ifndef CHILD_H
// COMPLETELY SKIPPED, since CHILD_H has been defined on the second line!
#endif

namespace mwe
{
   template<typename T>
   class Child_Imp_0 : public Child<T>  // BAM, Child has not been defined yet.
   { ... };
}
#endif 

#include <stdexcept>
#include <iostream>

namespace mwe
{
  ...
}
#endif

为了解决这个问题，你需要以某种方式打破循环依赖。正如@MooingDuck 在 cmets 中所说，将 Factory 移至其自己的专用标头可以轻松解决问题。