Question

是否可以强制std::make_shared使用类的新运算符？这与另一个SO question有关。根据该问题，std::make_shared使用自定义分配器：

从标准（§20.7.2.2.6shared_ptr创建）：

效果：分配适合T类型对象的内存，并通过placement new表达式在该内存中构造一个对象   :: 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。

Answer 2

排序。

你所做的是创建一个包含对齐存储的结构，其中包含一个清理对象的自定义驱逐舰，以及一个如果你应该这样做的布尔说。

然后放置新对齐的存储空间。

现在使用别名共享ptr构造函数将指向对齐存储的指针作为不同类型返回。

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

2 个答案: