从 C++ 中的另一个模板方法调用模板方法？

Question

我目前遇到了模板化方法的问题。我有这个实现模板方法的公共类：

namespace Private { class InternalClass; }

namespace Public
{
    class PublicClass
    {
    public:
        PublicClass();
        virtual ~PublicClass();

        template<class T>
        bool Add(bool primary);

    private:
        Private::InternalClass* _pInternal;
    };

    template<class T>
    bool PublicClass::Add(bool primary) { return _pInternal->Add<T>(primary); }
}

内部类是这样实现的：

namespace Private
{
    class InternalClass
    {
    public:
        InternalClass();
        virtual ~InternalClass();

        template <class T>
        bool Add(bool primary);
    };

    template<class T>
    bool InternalClass::Add(bool primary) { return false; }
}

由于提供的源无法使用此内部类标头，因此我必须在 PublicClass 标头中对其进行类转发，并将包含添加到 PublicClass.cpp 文件中的 PrivateClass.h 中。

1) 知道为什么我会收到以下错误：

错误：成员访问不完整类型“Private::InternalClass”/注意：转发>“Private::InternalClass”声明

2) 隐藏我的 PublicClass::Add() 实现的最佳方法是什么？

更新

如 Cornstalks 所述，错误 1) 的原因是 this。

对于 2)，如何在 PublicClass 头文件中不包含 PrivateClass.h 的情况下隐藏我的实现？

Answer 1

您遇到了一个非常有趣的问题——您想要实现 PImpl idiom，其中私有实现的类有一个模板方法。好吧，这可以解决，这意味着您可以隐藏模板的实现，但只有当您知道哪些类型将用于在您的程序中实例化您的 Add<T> 方法时。

假设，您的模板仅适用于 AClass 和 BClass 类型。然后您可以按如下方式拆分文件（cmets 是内联的）：

文件 public.h：

#ifndef PUBLIC_H
#define PUBLIC_H

// Forward declaration ! It's sufficient in this case !
namespace Private { class InternalClass; }

// Declare all classes your Add<T> method should work with
struct AClass {};
struct BClass {};

namespace Public
{
    class PublicClass
    {
    public:
        PublicClass() {}
        virtual ~PublicClass() {}

        template <typename T>
        bool Add(bool primary); // DO NOT implement this method, just declare

    private:
        Private::InternalClass* _pInternal;
    };

    // "Explicit instantiation declarations", for each type the method will work with:
    extern template bool PublicClass::Add<AClass>(bool primary);

    extern template bool PublicClass::Add<BClass>(bool primary);
}

#endif

文件 public.cpp：

#include "public.h"

// NOTE: this is hidden in CPP file, noone will see your implementation
namespace Private
{
    class InternalClass
    {
    public:
        InternalClass() {}
        virtual ~InternalClass() {}

        template <typename T>
        bool Add(bool primary);
    };

    // Magic! Here is the actual implementation of your private method
    template <typename T>
    bool InternalClass::Add(bool primary)
    {
        return false;
    }
}

namespace Public
{
    // Original definition moved to CPP file !
    template <typename T>
    bool PublicClass::Add(bool primary)
    {
        return _pInternal->Add<T>(primary);
    }

    // And again list the allowed types, this time using "explicit instantiation definitions"
    template bool PublicClass::Add<AClass>(bool primary);

    template bool PublicClass::Add<BClass>(bool primary);
}

文件 main.cpp：

#include "public.h"

int main()
{
    Public::PublicClass pc;
    pc.Add<AClass>(true); // works !
    pc.Add<BClass>(false); // works !

    // pc.Add<int>(true); linker error as expected,
    // becuase there is no explicit instantiation for Add<int>

    return 0;
}