child_impl.h

Question

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

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

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

我所有的类都是模板，因为会有一些参数可以是float或int或其他任何东西。

但是，在使所有模板一起正常播放时遇到了一些麻烦。我遇到的错误是围绕未知的模板名称

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

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

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在评论中所说，将Factory移至其专用的标头将很容易实现这一目的。

模板儿童班级工厂

child.h

child_impl.h

1 个答案: