c++ scoped_allocator-CSDN博客

本文链接：https://blog.csdn.net/qq_62784677/article/details/147569395

在 C++ 中，scoped_allocator 是一个用于管理嵌套分配器的库，它允许在容器中使用嵌套分配器，从而实现更灵活的内存管理。scoped_allocator 主要通过 std::scoped_allocator_adaptor 类模板来实现。以下是对 scoped_allocator 的详细介绍，包括其概念、使用方法和相关函数。

1. 概念

scoped_allocator 的核心思想是允许在容器中使用嵌套分配器。嵌套分配器是指分配器可以嵌套使用，例如一个分配器可以用来分配容器的内存，而另一个分配器可以用来分配容器中元素的内存。

内层分配器（Inner Allocator）：用于分配容器中元素的内存。
外层分配器（Outer Allocator）：用于分配容器本身的内存。

通过 scoped_allocator，可以实现以下功能：

使用不同的分配器来管理容器和元素的内存。
在容器嵌套时，可以更灵活地控制内存分配策略。

2. `std::scoped_allocator_adaptor`

std::scoped_allocator_adaptor 是 scoped_allocator 的核心类模板，它用于封装嵌套分配器的行为。它定义了如何在容器中使用内层和外层分配器。

模板参数

std::scoped_allocator_adaptor 的模板参数如下：

template <class OuterAlloc, class... InnerAllocs>
class scoped_allocator_adaptor;

OuterAlloc：外层分配器类型。
InnerAllocs...：内层分配器类型（可以有多个）。

构造函数

scoped_allocator_adaptor 提供了多种构造函数，用于初始化分配器：

默认构造函数：
```
scoped_allocator_adaptor();
```

使用外层分配器构造：

explicit scoped_allocator_adaptor(const OuterAlloc& outer_alloc);

使用外层和内层分配器构造：

scoped_allocator_adaptor(const OuterAlloc& outer_alloc, const InnerAllocs&... inner_allocs);

成员函数

scoped_allocator_adaptor 提供了许多成员函数，用于管理分配器的行为：

allocate 和 deallocate：
- allocate：分配内存。
```
pointer allocate(size_type n);
```
- deallocate：释放内存。
```
void deallocate(pointer p, size_type n);
```

construct 和 destroy：

construct：构造对象。

template <class T, class... Args>
void construct(T* p, Args&&... args);

destroy：销毁对象。
```
template <class T>
void destroy(T* p);
```

max_size：
- 返回分配器可以分配的最大对象数。
```
size_type max_size() const noexcept;
```
select_on_container_copy_construction：
- 在容器复制构造时选择分配器。
```
scoped_allocator_adaptor select_on_container_copy_construction() const;
```

3. 使用方法

以下是一个使用 scoped_allocator 的示例，展示如何在容器中使用嵌套分配器。

示例代码

#include <iostream>
#include <vector>
#include <memory>
#include <scoped_allocator>

// 定义一个简单的分配器
template <typename T>
struct MyAllocator {
    using value_type = T;

    MyAllocator() = default;

    template <typename U>
    MyAllocator(const MyAllocator<U>&) {}

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

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

int main() {
    // 使用 scoped_allocator_adaptor 包装分配器
    std::scoped_allocator_adaptor<MyAllocator<int>, MyAllocator<int>> alloc;

    // 创建一个 vector，使用嵌套分配器
    std::vector<int, std::scoped_allocator_adaptor<MyAllocator<int>, MyAllocator<int>>> vec(alloc);

    // 添加元素
    vec.push_back(10);
    vec.push_back(20);

    // 输出元素
    for (int val : vec) {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    return 0;
}

输出结果

Allocating 2 elements
Allocating 2 elements
10 20
Deallocating 2 elements
Deallocating 2 elements

4. 嵌套容器

scoped_allocator 特别适用于嵌套容器的情况。例如，一个 std::vector 中存储的是另一个 std::vector，可以通过嵌套分配器来管理内存。

示例代码

#include <iostream>
#include <vector>
#include <scoped_allocator>

// 定义一个简单的分配器
template <typename T>
struct MyAllocator {
    using value_type = T;

    MyAllocator() = default;

    template <typename U>
    MyAllocator(const MyAllocator<U>&) {}

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

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

int main() {
    // 使用 scoped_allocator_adaptor 包装分配器
    std::scoped_allocator_adaptor<MyAllocator<std::vector<int>>, MyAllocator<int>> alloc;

    // 创建一个嵌套的 vector
    std::vector<std::vector<int>, std::scoped_allocator_adaptor<MyAllocator<std::vector<int>>, MyAllocator<int>>> nestedVec(alloc);

    // 添加元素
    nestedVec.emplace_back();
    nestedVec.back().push_back(10);
    nestedVec.back().push_back(20);

    nestedVec.emplace_back();
    nestedVec.back().push_back(30);
    nestedVec.back().push_back(40);

    // 输出元素
    for (const auto& innerVec : nestedVec) {
        for (int val : innerVec) {
            std::cout << val << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

输出结果

Allocating 2 elements
Allocating 2 elements
Allocating 2 elements
Allocating 2 elements
10 20
30 40
Deallocating 2 elements
Deallocating 2 elements
Deallocating 2 elements
Deallocating 2 elements