C++ 仅当值为'；这是一个指针_C++_Templates_Pointers_Generics_Delete Operator

C++ 仅当值为'；这是一个指针

c++ templates pointers generics

C++ 仅当值为'；这是一个指针,c++,templates,pointers,generics,delete-operator,C++,Templates,Pointers,Generics,Delete Operator,假设你有一门课，比如： template<typename T> class Foo { public: T value; public: Foo(const T& value) { this->value = value; } public: ~Foo() { if(std::is_pointer<T>::value) delete value; } } 是否有一种方

假设你有一门课，比如：

template<typename T>
class Foo
{
public:
    T value;
public:
    Foo(const T& value)
    {
        this->value = value;
    }
public:
    ~Foo()
    {
        if(std::is_pointer<T>::value) delete value;
    }
}

是否有一种方法可以成功地检查

是否是指针，如果是，则删除它，而不会出现编译器错误？

使用专门的帮助器类，如下所示：

template<typename T> class delete_me {

public:

   static void destroy(T &value)
   {
   }
};

template<typename P>
class delete_me<P *> {

public:

   static void destroy(P *value)
   {
       delete value;
   }
};

模板类删除\u me{
公众：
静态空洞破坏（T和值）
{
}
};
模板
类删除\u me{
公众：
静态空洞破坏（P*值）
{
删除值；
}
};

还有你的析构函数：

~Foo()
{
    delete_me<T>::destroy(value);
}

~Foo（）
{
删除：销毁（值）；
}

使用专门的帮助器类，如下所示：

template<typename T> class delete_me {

public:

   static void destroy(T &value)
   {
   }
};

template<typename P>
class delete_me<P *> {

public:

   static void destroy(P *value)
   {
       delete value;
   }
};

模板类删除\u me{
公众：
静态空洞破坏（T和值）
{
}
};
模板
类删除\u me{
公众：
静态空洞破坏（P*值）
{
删除值；
}
};

还有你的析构函数：

~Foo()
{
    delete_me<T>::destroy(value);
}

~Foo（）
{
删除：销毁（值）；
}

只需假设资源自行管理即可。如果类型为

的变量没有释放资源，则假定它是预期行为

例如，如果您有一个传递给类模板的非所有者指针，您不希望它删除它，因为该指针是非所有者的

另一方面，

std:：unique_ptr

将自动释放它包含的指针

假设您有一个单例

Bar

，并且有一个函数

Bar:：instance

，返回一个

Bar*

：

// You don't want Foo to delete instance
Foo<Bar*> foo{Bar::instance()};

//您不希望Foo删除实例
Foo Foo{Bar:：instance（）}；

但使用唯一指针时，它将如下所示：

Foo<std::unique_ptr<Baz>> foo{std::make_unique<Baz>()};

Foo-Foo{std:：make_unique（）}；

指向

Baz

的指针将自动释放，就像您预期的那样

TL；DR如果您只需删除析构函数，您就已经有了最佳解决方案。