模板类的智能指针？

Question

我怀疑我不能直接使用 PIMPL 模式执行此操作。是否可以有一个指向模板类的智能指针？我无法通过转动shared_ptr 声明的旋钮进行编译。

// ============Foo.h ============
// Forward declare the implementation
template <typename T> class FooImpl;

class Foo
{
  public:
    Foo getInstance(const string& fooType);
    ...
  private:
    shared_ptr< FooImpl<T> > m_impl;
};

// ============FooImpl.h ============
template <typename T>
class FooImpl
{
    ...
};

在 Visual Studio 2008 下：“错误 C2065：'T'：未声明的标识符”。我在 GCC 下收到类似的错误。 如果我取消对 FooImpl 的参数化（以便 FooTempl 继承自 FooImpl），代码将编译。

我怀疑我无法参数化智能指针，但我可能错了。

编辑：second Visual Studio 错误更能说明问题：“错误 C3203: 'FooImpl' : unspecialized class template can't be used as a template argument for template parameter 'T', expected a实型”

杰夫

Answer 1

我不完全确定您要完成什么，但这有帮助吗？

尝试1：

// ============Foo.h ============
// Forward declare the implementation

template <typename T> class FooImpl;

template<class C>
class Foo
{
  public:
    Foo getInstance(const string& fooType);
    ...
  private:
    shared_ptr< FooImpl<C> > m_impl;
};

// ============FooImpl.h ============
template <typename T>
class FooImpl
{
    ...
};

尝试2：

// ============Foo.h ============
// Forward declare the implementation

class FooImplBase;

class Foo
{
  public:
    Foo getInstance(const string& fooType);
    ...
  private:
    shared_ptr< FooImplBase > m_impl;
};

// ============FooImpl.h ============
class FooImplBase {
  public:
    virtual void AnAPI();
    virtual int AnotherAPI();
};
template <typename T>
class FooImpl : public FooImplBase
{
    ...
};

Answer 2

您发布的代码无法编译，因为T 在Foo 的上下文中没有任何意义。编译器在这里需要一个名为 T 的类型，但那里不存在...不完全确定您要完成什么，但以下内容不能解决您的问题吗？

// ============Foo.h ============ 

class FooImplBase {
    virtual void WhateverFooImplIsSupposedToDo() = 0;
};

template <typename T> class FooImpl : public FooImplBase {
    T mInstance;
public:
    FooImpl(T const & pInstance) : mInstance(pInstance) {}
    virtual void WhateverFooImplIsSupposedToDo() 
    {
        // implementation which deals with instances of T
    }
}; 

class Foo 
{ 
  public: 
    Foo getInstance(const string& fooType) {
     // use m_impl->WhateverFooImplIsSupposedToDo...
    }    

    template < class T >
    Foo( T const & pInstance ) : m_impl(new FooImpl<T>(pInstance)) {}
  private: 
    shared_ptr< FooImplBase > m_impl; 
}; 

Answer 3

您做对了，只需确保已定义 T。这在 MSVC++ 2010 上为我编译：

#include <memory>

using namespace std;

template<class T>
class Blah {
public:
    Blah() { }
};

class Foo {
public:
    shared_ptr<Blah<int>> ptr;

    Foo() : ptr(new Blah<int>()) { }
};

如果您使用的旧编译器尚未包含 C++11 的此功能，请更改

shared_ptr<Blah<int>> ptr;

到

shared_ptr<Blah<int> > ptr;

所以编译器不认为>> 是右移。不过 C++11 没有这个问题。

Answer 4

我事先不知道我会有一个 Blah，只有一个 Blah。

从语言的角度来看，Blah<T> 没有意义，因为T 不存在。根据您的具体目标，您可以

把Foo也做成一个模板，这样你就可以声明一个模板参数T：

template<typename T>
class Foo
{
  public:
    Foo getInstance(const string& fooType);
    ...
  private:
    shared_ptr< FooImpl<T> > m_impl;
};

当您声明Foo<T> 类型的变量时，它“修复”了T 的选择；

或使FooImpl 明确派生自一个公共基础：

class FooBase {
    // need to define the interface here
};

// this is a class definition whereas previously you only needed a declaration
template<typename T>
class FooImpl: public FooBase {
    // definition here
};

class Foo
{
  public:
    Foo getInstance(const string& fooType);

    // we needed the definition of FooImpl for this member
    // in addition this member is quite obviously a template
    template<typename T>
    void
    set(FooImpl<T> const& foo)
    {
        m_impl.reset(new FooImpl<T>(foo));
    }

    // not a member template!
    void
    use()
    {
        // any use of m_impl will be through the FooBase interface
    }

  private:
    shared_ptr<FooBase> m_impl;
};

对于给定的Foo 实例，可以动态设置任何类型的FooImpl<T>，然后通过FooBase 接口使用。这是一种type erasure，因为它在 C++ 世界中被称为。

Answer 5

我们可以使用模板来编写一个通用的智能指针类。以下 C++ 代码演示了相同的内容。我们不需要调用 delete 'ptr'，当对象 'ptr' 超出范围时，它的析构函数会自动进行。

#include<iostream>
using namespace std;

// A generic smart pointer class
template <class T>
class SmartPtr
{
   T *ptr;  // Actual pointer
public:
   // Constructor
   explicit SmartPtr(T *p = NULL) { ptr = p; }

   // Destructor
   ~SmartPtr() {
    cout <<"Destructor called" << endl;  
    delete(ptr);
   }

   // Overloading dereferncing operator
   T & operator * () {  return *ptr; }

   // Overloding arrow operator so that members of T can be accessed
   // like a pointer (useful if T represents a class or struct or 
   // union type)
   T * operator -> () { return ptr; }
};

int main()
{
    SmartPtr<int> ptr(new int()); // Here we can create any data type pointer just like 'int'
    *ptr = 20;
    cout << *ptr;
    return 0;
}

输出：

20

调用析构函数