带模板函数的循环依赖

Question

我有一个带有以下声明的 A 类（A.h 文件）：

#ifndef __A_DEFINED__
#define __A_DEFINED__

class A
{
public:
  template<typename T> inline void doThat() const;
};

#endif

以及从该类派生的 B 类（B.h 文件）：

#ifndef __B_DEFINED__
#define __B_DEFINED__

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

class B : public A
{
public:
  void doThis() const { std::cout << "do this!" << std::endl; }
};

#endif

到目前为止，一切都很好。我的问题是函数 A::doThat() 使用 B::doThis():

template<typename T> inline void A::doThat() const { B b; b.doThis(); }

通常，循环依赖不会成为问题，因为我只需在 .cpp 文件中定义 A::doThat()。然而，就我而言，doThat 是一个模板函数，所以我不能这样做。

以下是我目前设想的解决方案：

1. 在 .cpp 文件中定义模板函数 A::doThat()。问题是我需要使用各种模板参数显式实例化所有调用（实际情况下可能有很多）。

2. 在A.h中声明A类后，添加#include "B.h"，然后定义A::doThat()函数。这在 Visual Studio 中运行良好，但 g++ 不喜欢它。

有没有巧妙的方法来解决这个问题？

编辑： 在实际情况下，不只有一个子类 B，而是多个（B、C、D 等）函数 A::doThat() 依赖于所有他们。函数 B::doThis() 也是模板化的。

Answer 1

B 类的默认模板参数可以工作：

#include <iostream>

// include A.h
class B;

class A
{
public:
    template<typename T, typename U = B> inline void doThat() const 
    {
        U b; b.doThis();
    }
};

// include B.h
class B : public A
{
public:
    void doThis() const { std::cout << "do this!" << std::endl; }
};

// main
int main()
{
    A a;
    a.doThat<int>();
}

Answer 2

通常允许父函数调用子函数的最好方法是在父函数中将该函数声明为纯虚函数，并在子函数中覆盖它。

#include <iostream>

class A
{
public:
    virtual ~A() = default;
    template<typename T> inline void doThat() const
    {
        // do some other stuff
        doThis();
    }
    virtual void doThis() const = 0; // pure virtual function
};

class B: public A
{
public:
    void doThis() const override
    {
        std::cout << "do this!" << std::endl;
    }
};

int main()
{
    B b;
    A* ap = &b;
    ap->doThat<int>();
}

Answer 3

以下内容适用于g++：

文件A.h：

#ifndef __A_DEFINED__
#define __A_DEFINED__

class A
{
public:
  template<typename T> inline void doThat() const;
};

#include "B.h"

template<typename T> inline void A::doThat() const { B b; b.doThis(); }

#endif

文件B.h：

#include <iostream>

#include "A.h"

// We check for the include guard and set it AFTER the inclusion of A.h
// to make sure that B.h is completely included from A.h again.
// Otherwise the definition of A::doThat() would cause a compiler error
// when a program includes B.h without having included A.h before.
#ifndef __B_DEFINED__
#define __B_DEFINED__

class B : public A
{
public:
  void doThis() const { std::cout << "do this!" << std::endl; }
};

#endif

文件test_A.cpp：

// In this test case we directly include and use only A.
#include "A.h"
#include "A.h" // We test whether multiple inclusion causes trouble.

int main() {
    A a;
    a.doThat<int>();
}

文件test_B.cpp：

// In this test case we directly include and use only B.
#include "B.h"
#include "B.h" // We test whether multiple inclusion causes trouble.

int main() {
    B b;
    b.doThat<int>();
    b.doThis();
}

另类想法：

我不知道您（或某些编码约定）是否坚持为每个类使用单独的头文件，但如果不是，以下应该可以工作：

您可以将class A 和class B 的定义以及成员函数模板A::doThat<typename>()（按此顺序）放在一个头文件AandB.h（或任何您喜欢的名称）中。

Answer 4

这需要多态性。使用多态有两种选择：

1. 动态多态性，即将A 设为抽象基类并虚拟调用doThis()：

   struct A
   {
       virtual void do_this() const = 0;
       template<typename T>
       void doThat() const { doThis(); }
   };
   
   struct B : A
   {
       void doThis() const override { /* ... */ }
   };
   

   当然，这仅适用于 doThis() 未模板化的情况。如果需要，可以使用

2. 静态多态性，即CRTP，当

   template<typename Derived>
   struct A
   {
       template<typename T>
       void doThat() const { static_cast<const Derived*>(this)->template doThis<T>(); }
   };
   
   struct B : A<B>
   {
       template<typename T>
       void doThis() const { /* ... */ }
   };
   

如果（在您的示例代码中）B::doThis() 不是为同一个对象调用的，但对于某些临时对象，您可以

template<typename typeB>
struct A
{
    template<typename T>
    void doThat() const { typeB b; b.template doThis<T>(); }
};