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

Question

我目前遇到模板化方法的问题。我有一个实现模板方法的公共(public)类:

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; }
}

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

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

error : member access into incomplete type 'Private::InternalClass' / note: forward >declaration of 'Private::InternalClass'

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

已更新

错误原因 1) 是因为 this正如 Cornstalks 所说。

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

Answer 1

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

例如，您的模板将仅适用于类型 AClass和 BClass .然后您可以按如下方式拆分文件(内联注释):

文件 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;
}