是否可以强制`std :: make_shared`使用类的new运算符？

Question

是否可以强制std::make_shared使用类的新运算符？这涉及另一个SO问题.根据该问题,std::make_shared使用自定义分配器:

从标准(§20.7.2.2.6shared_ptr创建):

效果:分配适合T类型对象的内存,并通过放置新表达式:: new(pv)T(std :: forward(args)...)在该内存中构造一个对象.

因此,我认为我可以使用自定义展示位置新运算符,但这似乎是错误的

// std::cout
#include <iostream>

// std::make_shared
#include <memory>

// Track what we're making
struct Foo {
    Foo() {
        std::cout << "Foo constructor" << std::endl;
    }
    Foo(Foo const & foo) {
        std::cout << "Foo copy constructor" << std::endl;
    }
    Foo(Foo && foo) {
        std::cout << "Foo move constructor" << std::endl;
    }
    Foo & operator = (Foo const & foo) {
        std::cout << "Foo copy assignment" << std::endl;
        return *this;
    }
    Foo & operator = (Foo && foo) {
        std::cout << "Foo move assignment" << std::endl;
        return *this;
    }
    void * operator new(std::size_t size) throw(std::bad_alloc) {
        std::cout << "Foo new" << std::endl;
        return ::operator new(size);
    }
    void * operator new(std::size_t size, void * p) throw() {
        std::cout << "Foo placement new" << std::endl;
        return ::operator new(size,p);
    }
    void* operator new (std::size_t size, std::nothrow_t const & nothrow_value) 
        throw()
    {
        std::cout << "Foo nonthrowing new" << std::endl;
        return ::operator new(size,nothrow_value);

    }
    void operator delete(void * p, std::size_t size) {
        std::cout << "Foo delete" << std::endl;
        ::operator delete(p);
    }
    ~Foo() {
        std::cout << "Foo destructor" << std::endl;
    }
};

int main() {
    std::cout << "---Creating foo" << std::endl;
    auto foo = std::make_shared <Foo> ();
    std::cout << "---Creating foo2" << std::endl;
    auto foo2 = std::shared_ptr <Foo> (new Foo());
    std::cout << "---Creating foo3" << std::endl;
    auto foo3 = std::allocate_shared <Foo> (std::allocator <Foo>());
    std::cout << "---fin" << std::endl;
}

这使

---Creating foo
Foo constructor
---Creating foo2
Foo new
Foo constructor
---Creating foo3
Foo constructor
---fin
Foo destructor
Foo destructor
Foo delete
Foo destructor

还有一个试图强制分配器调用自定义新运算符的调用std::allocate_shared.在任何情况下,有没有办法std::make_shared调用自定义新运算符而不定义一个全新的分配器？

Answer 1

不,这是不可能的(有make_shared).

由于类的自定义分配器T通常会被编写和优化(例如使用池)以期望分配大小T,并且make_shared将分配更多的内存,我想它不被认为是支持的重要特性.

此外,该标准规定allocate_shared了您希望使用自定义分配器的情况.