#include<iostream>
#include <vector>
using namespace std;
class node{
public:
    node(){
        cout << "build node!" <<endl;
    }
};
int main(){
    vector<node> arr;
    arr.resize(10);
    return 0;
}

#include <iostream>
#include <vector>
#include <memory>   // 包含 std::allocator

// 自定义分配器类
template <typename T>
class MyAllocator {
public:
    // 类型定义
    using value_type = T;
    // 分配内存
    T* allocate(std::size_t n) {}
    // 释放内存
    void deallocate(T* p, std::size_t n) {}
    // 构造对象
    template <typename... Args>
    void construct(T* p, Args&&... args) {}
    // 销毁对象
    void destroy(T* p) {}
};
int main() {
    // 使用自定义分配器创建 vector
    std::vector<int, MyAllocator<int>> myVector;
    return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <array>
#include <cstdlib>  // for byte
#include <memory_resource>
using namespace std;
int main()
{
    // 在栈上分配一些内存：
    array<byte, 200000> buf;
    // 将它用作vector的初始内存池：
    pmr::monotonic_buffer_resource pool{buf.data(), buf.size()};
    pmr::vector<string> coll{&pool};
    for (int i = 0; i < 1000; ++i) {
        coll.emplace_back("just a non-SSO string");
    }
    cout << buf.begin() << " " << buf.end() <<endl;
    cout << coll.begin().base() << " " << coll.end().base() <<endl;
    return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <array>
#include <cstdlib>  // for byte
#include <memory_resource>
using namespace std;
int main()
{
    // 在栈上分配一些内存：
    array<byte, 20> buf;
    // 将它用作vector的初始内存池：
    pmr::monotonic_buffer_resource pool{buf.data(), buf.size()};
    pmr::vector<string> coll{&pool};
    for (int i = 0; i < 1000; ++i) {
        coll.emplace_back("just a non-SSO string");
    }
    cout << buf.begin() << " " << buf.end() <<endl;
    cout << coll.begin().base() << " " << coll.end().base() <<endl;
    return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <array>
#include <cstdlib>  // for byte
#include <memory_resource>
using namespace std;
int main()
{
    // 在栈上分配一些内存：
    array<byte, 20> buf;
    // 将它用作vector的初始内存池：
    pmr::monotonic_buffer_resource pool{buf.data(), buf.size(),pmr::null_memory_resource()};
    pmr::vector<string> coll{&pool};
    for (int i = 0; i < 1000; ++i) {
        coll.emplace_back("just a non-SSO string");
    }
    cout << buf.begin() << " " << buf.end() <<endl;
    cout << coll.begin().base() << " " << coll.end().base() <<endl;
    return 0;
}

std::pmr::synchronized_pool_resource myPool;

std::pmr::synchronized_pool_resource myPool{std::pmr::get_default_resource()};

#include <memory_resource>
#include <vector>
#include <iostream>
using namespace std;
int main() {
    // 创建一个静态缓冲区
    int buf[1024] = {0};

    // 创建一个 monotonic_buffer_resource，并使用静态缓冲区
    pmr::monotonic_buffer_resource resource(buf, sizeof(buf));
    // 创建一个使用该内存资源的 vector
    pmr::vector<int> vec(&resource);
    vec.push_back(0);
    cout<< (unsigned long long)vec.data() - (unsigned long long )buf << endl;
    // 向 vector 添加数据
    for (int i = 1; i < 10; ++i) {
        vec.push_back(i);
    }
    unsigned long long off = (unsigned long long)vec.data() - (unsigned long long )buf;
    cout<< off << endl;
    for(int i=0;i< off/sizeof(int) + vec.size();i++){
        cout<< buf[i] << " ";
    }
    cout << endl;
    return 0;
}

static std::pmr::synchronized_pool_resource myPool;
// 设置myPool为新的默认内存资源：
std::pmr::memory_resource* old = std::pmr::set_default_resource(&myPool);
...
// 恢复旧的默认内存资源：
std::pmr::set_default_resource(old);

int main()
{
    static std::pmr::synchronized_pool_resource myPool;
    ...
}

memory_resource* myResource()
{
    static std::pmr::synchronized_pool_resource myPool;
    return &myPool;
}

#include <iostream>
#include <string>
#include <memory_resource>

class Tracker : public std::pmr::memory_resource
{
private:
    std::pmr::memory_resource *upstream;    // 被包装的内存资源
    std::string prefix{};
public:
    // 包装传入的或者默认的资源：
    explicit Tracker(std::pmr::memory_resource *us
            = std::pmr::get_default_resource()) : upstream{us} {
    }

    explicit Tracker(std::string p, std::pmr::memory_resource *us
            = std::pmr::get_default_resource()) : upstream{us}, prefix{std::move(p)} {
    }
private:
    void* do_allocate(size_t bytes, size_t alignment) override {
        std::cout << prefix << "allocate " << bytes << " Bytes\n";
        void* ret = upstream->allocate(bytes, alignment);
        return ret;
    }
    void do_deallocate(void* ptr, size_t bytes, size_t alignment) override {
        std::cout << prefix << "deallocate " << bytes << " Bytes\n";
        upstream->deallocate(ptr, bytes, alignment);
    }
    bool do_is_equal(const std::pmr::memory_resource& other) const noexcept override {
        // 是同一个对象？
        if (this == &other)
            return true;
        // 是相同的类型并且prefix和upstream都相等？
        auto op = dynamic_cast<const Tracker*>(&other);
        return op != nullptr && op->prefix == prefix && upstream->is_equal(other);
    }
};

#include <string>
#include <memeory_resource>

// 支持多态分配器的顾客类型
// 分配器存储在字符串成员中
class PmrCustomer
{
private:
    std::pmr::string name;  // 也可以用来存储分配器
public:
    using allocator_type = std::pmr::polymorphic_allocator<char>;

    // 初始化构造函数：
    PmrCustomer(std::pmr::string n, allocator_type alloc = {}) : name{std::move(n), alloc} {
    }

    // 带有分配器的移动，构造函数：
    PmrCustomer(const PmrCustomer& c, allocator_type alloc) : name{c.name, alloc} {
    }

    PmrCustomer(PmrCustomer&& c, allocator_type alloc) : name{std::move(c.name), alloc} {
    }

    // setter/getter：
    void setName(std::pmr::string s) {
        name = std::move(s);
    }
    std::pmr::string getName() const {
        return name;
    }
    std::string getNameAsString() const {
        return std::string{name};
    }
};