Question

我不确定一个合适的头衔。这看起来确实令人困惑。对不起。我不是程序员。所以拜托，请耐心等待。我肯定错误地使用了一些术语。

这就是我想要实现的目标：

有一个基类A_base，其中定义了一些嵌套类（子类？）（B_base）。 A_base将具有不需要专业化的各种常见功能。嵌套类提供了一些与另一个应用程序通信的接口（其中有回调，我根据自己的需要定义）。



class A_base
{
public:

void a_function()
{
    std::cout << "This is a base a_function\n" ;
}

void a_b_function();

class B_base
{
  public:

  void b_function()
  {
    std::cout << "This is a base b_function\n" ;
  }

  void b_a_function();

  virtual void b_c_function1(){return;};
  virtual void b_c_function2(){return;};

  B_base(const std::string& name_in, A_base* ptr_A_in):
    name(name_in), ptr_A(ptr_A_in)
  {}

  protected:
    const std::string name;
    A_base* ptr_A;
};

B_base* b_object;

A_base(const std::string& name_in):
    b_object(new B_base(name_in, this)), name(name_in)
{}

protected:
    const std::string name;
};

void A_base::a_b_function()
{
    b_object->b_function();
}

void A_base::B_base::b_a_function()
  {
    ptr_A->a_function();
  }

class A_base { public: void a_function() { std::cout << "This is a base a_function\n" ; } void a_b_function(); class B_base { public: void b_function() { std::cout << "This is a base b_function\n" ; } void b_a_function(); virtual void b_c_function1(){return;}; virtual void b_c_function2(){return;}; B_base(const std::string& name_in, A_base* ptr_A_in): name(name_in), ptr_A(ptr_A_in) {} protected: const std::string name; A_base* ptr_A; }; B_base* b_object; A_base(const std::string& name_in): b_object(new B_base(name_in, this)), name(name_in) {} protected: const std::string name; }; void A_base::a_b_function() { b_object->b_function(); } void A_base::B_base::b_a_function() { ptr_A->a_function(); }

从A_base（A_derived）中导出一个模板化类，其中包含一些额外的专用功能和另一个嵌套类（C_class，也是模板化的）。我选择这个来优化程序的延迟。它不一定总是闪电般快，但逻辑中有一条必须尽可能快的特定路径。因此，我试图通过使用模板来消除不必要的分支。

enum Side{BB=0,SS=1};

template<bool B>
class A_derived : public A_base
{
public:    
void a_function()
{
    std::cout << "This is a derived a_function\n" ;
}    

template<Side S>
class C_class
{
  public:

  void c_function();      

  C_class(const std::string& name_in, A_derived* ptr_A_in):
  name(name_in), ptr_A(ptr_A_in)
  {}

  protected:
  const std::string name;
  A_derived* ptr_A;
};

C_class<Side::BB> c_object_bb;
C_class<Side::SS> c_object_ss;

A_derived(const std::string& name_in):
  A_base(name_in), c_object_bb(name_in, this), c_object_ss(name_in, this)
{}

};

这里我定义了专门的功能（应该是快速的功能）：

enum Side{BB=0,SS=1}; template<bool B> class A_derived : public A_base { public: void a_function() { std::cout << "This is a derived a_function\n" ; } template<Side S> class C_class { public: void c_function(); C_class(const std::string& name_in, A_derived* ptr_A_in): name(name_in), ptr_A(ptr_A_in) {} protected: const std::string name; A_derived* ptr_A; }; C_class<Side::BB> c_object_bb; C_class<Side::SS> c_object_ss; A_derived(const std::string& name_in): A_base(name_in), c_object_bb(name_in, this), c_object_ss(name_in, this) {} };

最重要的是，需要能够从嵌套类B_base的方法中调用一些专用函数。专用函数属于C_class。因此，B_base对此一无所知。但我试图通过将A_base指针强制转换为A_derived指针来避免这种情况。我知道在每种情况下都会使用什么样的A_derived。

问题是，必须根据所使用的A_derived的版本调用C_class函数。但是B_base本身并不是一个模板化的类。所以，显然以下内容并不像我希望的那样工作：

template<> template<>
void A_derived<false>::C_class<Side::BB>::c_function()
{
      std::cout << "This is a false-BB c_function\n" ;  
}

template<> template<>
void A_derived<false>::C_class<Side::SS>::c_function()
{
      std::cout << "This is a false-SS c_function\n" ;  
}

template<> template<>
void A_derived<true>::C_class<Side::BB>::c_function()
{
      std::cout << "This is a true-BB c_function\n" ;  
}

template<> template<>
void A_derived<true>::C_class<Side::SS>::c_function()
{
      std::cout << "This is a true-SS c_function\n" ;  
}

template<> template<>
void A_derived<false>::C_class<Side::BB>::c_function()
{
      std::cout << "This is a false-BB c_function\n" ;  
}

template<> template<>
void A_derived<false>::C_class<Side::SS>::c_function()
{
      std::cout << "This is a false-SS c_function\n" ;  
}

template<> template<>
void A_derived<true>::C_class<Side::BB>::c_function()
{
      std::cout << "This is a true-BB c_function\n" ;  
}

template<> template<>
void A_derived<true>::C_class<Side::SS>::c_function()
{
      std::cout << "This is a true-SS c_function\n" ;  
}

它只是抱怨重新定义功能。如果我添加模板＆lt;＆gt; syntaxis它抱怨那里没有模板。这有点真实。不能责怪编译器。

你能告诉我一个合理的解决方案吗？如何从基类的嵌套类的方法中调用派生类的嵌套类的模板化函数？

谢谢。

已添加：所以，有人在评论中建议我使用虚拟功能。经过一番思考后我决定澄清一下。实际上，B_base的功能是虚拟的。这不是我的代码。我只需处理它。虚函数没什么帮助的原因是我不能简单地从B_base中导出我的A_base（由于某些原因）。对于B_base的大部分功能，我可以使用一些常见的定义。但是，有10％的B_base函数需要专门化，具体取决于实例化的A_derived。我的备份解决方案是根本不使用B_base，而是让一些派生的B_derived在我的A_derived中完全定义。不幸的是，这意味着编写无限量的无用代码。因为大多数B_base函数不依赖于A_derived的类型。

从基类

0 个答案: