C++ 为std:：shared_ptr指定一个Deleter，该Deleter可用于特定类型或其派生类型的所有对象

在我的项目中，我有以下课程

class Base
{
    public:
    virtual ~Base(){};
}

class Der1: public Base
{
    public:
    virtual ~Der1(){};
}

class Der2: public Base
{
    public:
    virtual ~Der2(){};
}

我将这些类的对象保存为

std:：shared\u ptr

。我需要为所有类型为

Base

或其任何

派生类型的对象提供自定义删除程序

我希望deleter方法中的代码将对所有这些对象执行相同的操作，比如

class Deleter
{
    public:
    void operator()( Base * b )
    {
        //Do something
        delete b;
    }
}

而不是在每个对象的构造过程中提供deleter，如

std::shared_ptr< Der1 > pDer1( new Der1(), Deleter() );
std::shared_ptr< Der2 > pDer2( new Der2(), Deleter() );

std:：shared_ptrpDer1（新的Der1（），Deleter（））；
std:：sharedptrpDer2（新的Der2（），Deleter（））；

是否有一种方法可以指定类似“对于所有指向Base类型或其派生类型的对象的共享指针，使用
Deleter
进行删除？”？
由于deleter类只是在shared\u ptr的构造函数中使用的，如何为特定类型指定deleter呢？
我会在Base中编写一个creation/factory函数，返回正确派生类型的shared\u ptr。大意如下：

class Base
{
  //...public...
  template <class Derived>
  static std::shared_ptr<Base> create()
  {
    return std::shared_ptr<Base>(new Derived, Deleter());
  }
};

类基
{
//……公众。。。
模板
静态std:：shared_ptr create（）
{
返回std:：shared_ptr（新派生的Deleter（））；
}
};

编辑：函数需要是静态的

如果派生的参数不止一个，则可以使用可变模板和完美转发来解决

编辑：

如下所示（对于多个参数派生构造函数）：

#包括
#包括
结构基础；
结构删除器
{
void运算符（）（基*b）；
};
结构基
{
//……公众。。。
模板
静态std：：共享\u ptr创建（Args&&…Args）
{
返回std:：shared_ptr（新派生的（std:：forward（args）…），Deleter（））；
}
虚拟~Base（）{}
};
void Deleter:：operator（）（Base*b）{delete b；}
派生结构：基
{
派生（整数a、整数b、整数c）
{
}
};
int main（）{
std:：shared_ptr p=Base:：create（1,2,3）；
返回0；
}
类型别名可以接受吗？你是说std:：shared\u ptr的类型别名吗？我不认为在
Base
中重写
操作符delete
是一个合理的选择。@WhozCraig我的意思是为所有Base或Der类型的对象专门化std:：shared指针，可能是通过SFINAE（我对这个概念不太熟悉）使用std:：enable_if和std:：is_base_of，这样我就可以为这样的共享指针指定删除器。是的，现在我想起来了，重写
操作符delete
会很有趣，但不管怎样都不是很有帮助。不过写一个jig很新颖。
#include <iostream>
#include <memory>

struct Base;

struct Deleter
{
    void operator()(Base* b);
};

struct Base
{
  //...public...
  template <class Derived, class ... Args>
  static std::shared_ptr<Base> create(Args&&... args)
  {
    return std::shared_ptr<Base>(new Derived(std::forward<Args>(args)...), Deleter());
  }
  virtual ~Base(){}
};

void Deleter::operator()(Base* b){ delete b; }


struct Derived : Base
{
  Derived(int a, int b, int c)
  {
  }
};

int main() {
    std::shared_ptr<Base> p = Base::create<Derived>(1,2,3);
    return 0;
}