STL中的内存分配器

一、operator new 和 new operator 的区别

1.1、new operator

new 运算符是 C++ 提供的语法糖，用于在堆上动态分配内存并同时调用构造函数初始化对象。

• 功能:

  • 分配足够的内存来存储对象。
  • 调用对象的构造函数，执行初始化。
  • 返回指向分配内存的指针。

• 语法:

  Type* ptr = new Type(args);      // 动态分配单个对象
  Type* arrayPtr = new Type[size]; // 动态分配数组

1.2、 operator new

operator new 是一个函数，用于在堆上分配原始的未初始化内存。它不调用构造函数，只是纯粹地分配内存。

• 功能:

  • 分配原始内存块，不进行任何初始化。
  • 由 new 运算符在幕后调用，也可以直接调用 operator new 来分配内存。

• 语法:

  void* ptr = operator new(size_t size);

1.3、注意事项

• 两者之间的区别对于delete也适用
• operator new 是一个可以被重载的全局或类成员函数，他是一个函数！函数！函数！允许自定义内存分配行为。
• operator new 不会调用构造函数，因此它返回的是未初始化的内存块。

1.4、operator new 和 malloc 的区别与联系

实质上operator new是对 malloc的又一次封装，使其更加符合C++语言的习惯

void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
	void *p;
	while ((p = malloc(size)) == 0)
	if (_callnewh(size) == 0)
	{
		// 如果申请内存失败了，这里会抛出bad_alloc 类型异常
		static const std::bad_alloc nomem;
		_RAISE(nomem);
	}
	return (p);
}

同样的， operator delete 也是对 free 的封装。

二、placement new

这是 new 运算符的一个特殊形式，它允许你在指定的内存位置上构造对象，而不是分配新的内存。使用方式如下：

void* memory = operator new(sizeof(MyClass));
MyClass* obj = new(memory) MyClass();

其中 MyClass 是类，最终构造好的对象在obj上。使用 Placement new 构造的对象通常需要显式调用析构函数来正确地销毁对象。

obj->~MyClass();
operator delete(memory)

为什么要讲placement new呢，因为自定义内存分配器和标准的默认实现内存分配器都是基于 placement new 的二次封装

三、std::allocator

std::allocator 旨在将内存申请和对象构造分离。std::allocator 是 C++ 标准库提供的默认分配器，实现了最基本的内存分配和对象管理功能。其定义位于头文件 <memory> 中。

主要成员函数：

• allocate：分配未构造的内存。

pointer allocate(size_type n);

• deallocate：释放先前分配的内存。

void deallocate(pointer p, size_type n);

• construct：在已分配的内存上构造对象。

void construct(pointer p, const T& val); // C++17之前

• destroy：调用对象的析构函数。

void destroy(pointer p); //C++17之前

**注意：**从 C++17 开始，construct 和 destroy 都被移除了，建议使用 std::allocator_traits 或者直接使用 std::uninitialized_fill 等算法。

**举例：**使用默认分配器

using Alloc = std::allocator<int>;
Alloc alloc; // 创建一个分配int的allocator
// 分配10个int的空间
int* p = std::allocator_traits<Alloc>::allocate(alloc, 10);
// 在分配的内存上构造对象
for (int i = 0; i < 10; ++i) {
    std::allocator_traits<Alloc>::construct(alloc, p + i, i);
}
// 销毁对象
for (int i = 0; i < 10; ++i) {
    std::allocator_traits<Alloc>::destroy(alloc, p + i);
}
// 释放内存
std::allocator_traits<Alloc>::deallocate(alloc, p, 10);

四、自定义分配器

自定义分配器允许开发者控制内存管理策略。例如，可以实现一个内存池分配器，以减少频繁的内存分配和释放带来的开销。

一个自定义分配器需要实现以下几个接口：

typedef：为使用的类型定义别名，C++11后推荐使用 using
allocate(n)：分配能容纳n个对象的内存
deallocate(p, n)：释放前面分配的内存
construct(p, val)：在指针p所指向的内存上构造一个对象，其值为val
destroy(p)：销毁指针p所指向的对象

**示例：**一个模板

template <class T>
class MyAllocator {
public:
	using value_type = T;
 
	MyAllocator() = default;
	template <class U> constexpr MyAllocator(const MyAllocator<U>&) noexcept {}
 
	T* allocate(std::size_t n) {
		// 你的内存分配策略
	}
 
	void deallocate(T* p, std::size_t) noexcept {
		// 你的内存释放策略
	}
 
	template<typename... Args>
	void construct(T* p, Args&&... args) {
		// 你的对象构造策略
	}
 
	void destroy(T* p) {
		// 你的对象销毁策略
	}
};
 
template <class T, class U>
bool operator==(const MyAllocator<T>&, const MyAllocator<U>&) { return true; }
 
template <class T, class U>
bool operator!=(const MyAllocator<T>&, const MyAllocator<U>&) { return false; }

**示例：**一个实例

#include <memory>
#include <cstddef>  // for std::size_t
#include <utility>  // for std::forward

template <class T>
class MyAllocator {
public:
    using value_type = T;

    // 默认构造函数
    MyAllocator() = default;

    // 允许从其他类型的分配器转换构造
    template <class U>
    constexpr MyAllocator(const MyAllocator<U>&) noexcept {}

    // 内存分配策略
    T* allocate(std::size_t n) {
        if (n == 0) return nullptr;
        if (n > std::numeric_limits<std::size_t>::max() / sizeof(T)) { // 查询size_t的最大值
            throw std::bad_alloc();
        }
        return static_cast<T*>(::operator new(n * sizeof(T)));
    }

    // 内存释放策略
    void deallocate(T* p, std::size_t) noexcept {
        ::operator delete(p);
    }

    // 对象构造策略（可选）
    template <typename... Args>
    void construct(T* p, Args&&... args) {
        new (p) T(std::forward<Args>(args)...);
    }

    // 对象销毁策略（可选）
    void destroy(T* p) {
        p->~T();
    }
};

// 比较相等性，通常分配器是无状态的
template <class T, class U>
bool operator==(const MyAllocator<T>&, const MyAllocator<U>&) {
    return true;
}

template <class T, class U>
bool operator!=(const MyAllocator<T>&, const MyAllocator<U>&) {
    return false;
}

从 C++11 开始，引入了 std::allocator_traits，用于统一和简化分配器的实现。它为分配器提供了默认实现和辅助功能，建议在自定义分配器中使用。所以其实上述代码可以简化部分实现

template <class T>
class MyAllocator {
public:
    using value_type = T;

    // 默认构造函数
    MyAllocator() = default;

    // 允许从其他类型的分配器转换构造
    template <class U>
    constexpr MyAllocator(const MyAllocator<U>&) noexcept {}

    // 内存分配策略
    T* allocate(std::size_t n) {
        if (n == 0) return nullptr;
        if (n > std::numeric_limits<std::size_t>::max() / sizeof(T)) { // 查询size_t的最大值
            throw std::bad_alloc();
        }
        return static_cast<T*>(::operator new(n * sizeof(T)));
    }

    // 内存释放策略
    void deallocate(T* p, std::size_t) noexcept {
         ::operator delete(p);
    }
};

五、STL中使用自定义分配器

自定义分配器可以用于STL中的任何容器，包括vector、list等。以下是一个使用自定义分配器的vector的例子

std::vector<int, MyAllocator<int>> vc;

vc.push_back(1);
vc.push_back(2);
vc.push_back(3);
vc.push_back(4);

我们在自定义的内存分配器中的allocate方法中添加一个打印值，可以看到进行了三次内存的申请。