new (pointer) Type(constructor_arguments);

// 標(biāo)準(zhǔn)庫(kù)中的 placement new 聲明（不可重載）
void* operator new(size_t, void* ptr) noexcept {
    return ptr;  // 直接返回傳入的指針
}

new (pointer) Type(constructor_arguments);

#include <iostream>
struct Example {
    int value;
    Example(int val) : value(val) {
        std::cout << "Constructed at " << this << " with value " << value << std::endl;
    }
    ~Example() {
        std::cout << "Destructed at " << this << std::endl;
    }
};
int main() {
    // 手動(dòng)分配一塊內(nèi)存
    void* buffer = operator new(sizeof(Example));
    // 使用placement new在這塊內(nèi)存上構(gòu)造對(duì)象
    Example* obj = new (buffer) Example(42);
    // 顯式調(diào)用析構(gòu)函數(shù)（這很重要?。?
    obj->~Example();
    // 釋放內(nèi)存
    operator delete(buffer);
    return 0;
}

// 自定義全局 operator new
void* operator new(size_t size){
	std::cout << "Allocating " << size << " bytes\n";
	return malloc(size);
}

// 僅分配內(nèi)存，不構(gòu)造對(duì)象
void* raw_mem = operator new(sizeof(MyClass));

// 需要手動(dòng)構(gòu)造對(duì)象（例如通過(guò) placement new）
MyClass* obj = new (raw_mem) MyClass();  // 調(diào)用構(gòu)造函數(shù)

// 必須手動(dòng)析構(gòu)和釋放
obj->~MyClass();
operator delete(raw_mem);

#include <iostream>
#include <vector>
template<typename T>
class TrackingAllocator {
public:
    using value_type = T;

    TrackingAllocator() = default;
    
	// 支持 Rebinding（重新綁定)
    template<typename U>
    TrackingAllocator(const TrackingAllocator<U>&) {}

    T* allocate(size_t n) {
        size_t bytes = n * sizeof(T);
        std::cout << "Allocating " << bytes << " bytes\n";
        return static_cast<T*>(::operator new(bytes));
    }

    void deallocate(T* p, size_t n) {
        ::operator delete(p);
        std::cout << "Deallocating " << n * sizeof(T) << " bytes\n";
    }

    // 支持同類型分配器比較（無(wú)狀態(tài)）
    bool operator==(const TrackingAllocator&) { return true; }
    bool operator!=(const TrackingAllocator&) { return false; }
};

// 使用示例
int main() {
    // 使用自定義分配器
    std::vector<int, TrackingAllocator<int>> vec;
    vec.push_back(42);  // 輸出分配信息
    vec.push_back(13);  // 輸出分配信息
    // 清空向量
    vec.clear();  // 輸出釋放信息
    return 0;
}

#include <iostream>
#include <memory>  // std::allocator_traits

template <typename T>
struct SimpleAllocator {
    using value_type = T;

    // 必須提供 allocate 和 deallocate
    T* allocate(size_t n) {
        return static_cast<T*>(::operator new(n * sizeof(T)));
    }
    void deallocate(T* p, size_t n) {
        ::operator delete(p);
    }
    // 不提供 construct/destroy，由 allocator_traits 提供默認(rèn)實(shí)現(xiàn)
};

struct Widget {
    int id;
    Widget(int i) : id(i) { std::cout << "Construct Widget " << id << "\n"; }
    ~Widget() { std::cout << "Destroy Widget " << id << "\n"; }
};

int main() {
    using Alloc = SimpleAllocator<Widget>;
    Alloc alloc;
    // 1. 分配內(nèi)存（通過(guò) allocator_traits）
    auto p = std::allocator_traits<Alloc>::allocate(alloc, 1);
    // 2. 構(gòu)造對(duì)象（即使 SimpleAllocator 沒(méi)有 construct 方法?。?
    std::allocator_traits<Alloc>::construct(alloc, p, 42);  // 調(diào)用 Widget(42)
    // 3. 析構(gòu)對(duì)象（即使 SimpleAllocator 沒(méi)有 destroy 方法?。?
    std::allocator_traits<Alloc>::destroy(alloc, p);
    // 4. 釋放內(nèi)存
    std::allocator_traits<Alloc>::deallocate(alloc, p, 1);
    return 0;
}

#include <iostream>
#include <memory>  // std::allocator_traits

template <typename T>
class TrackingAllocator {
    size_t total_allocated = 0;
public:
    using value_type = T;

    T* allocate(size_t n) {
        total_allocated += n * sizeof(T);
        std::cout << "Allocated " << n * sizeof(T) << " bytes (Total: " << total_allocated << ")\n";
        return static_cast<T*>(::operator new(n * sizeof(T)));
    }

    void deallocate(T* p, size_t n) {
        total_allocated -= n * sizeof(T);
        std::cout << "Deallocated " << n * sizeof(T) << " bytes (Remaining: " << total_allocated << ")\n";
        ::operator delete(p);
    }

    // 支持比較（相同類型的 TrackingAllocator 才等價(jià)）
    bool operator==(const TrackingAllocator& other) const {
        return false;  // 有狀態(tài)，不同實(shí)例不能混用
    }
    bool operator!=(const TrackingAllocator& other) const {
        return true;
    }
};

int main() {
    using Alloc = TrackingAllocator<int>;
    Alloc alloc1, alloc2;

    auto p1 = std::allocator_traits<Alloc>::allocate(alloc1, 2);
    auto p2 = std::allocator_traits<Alloc>::allocate(alloc2, 3);
    // 必須用相同的 allocator 實(shí)例釋放！
    std::allocator_traits<Alloc>::deallocate(alloc1, p1, 2);
    std::allocator_traits<Alloc>::deallocate(alloc2, p2, 3);
    return 0;
}