C++中分配器allocator的实现

vector<int> v;  // 就这样用，完全不用管分配器
v.push_back(10);
// 默认分配器工作得很好

// vector其实有两个模板参数
vector<int> v;  // 等价于：
vector<int, allocator<int>> v;  // 第二个参数就是分配器

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> v;
    
    cout << "初始容量: " << v.capacity() << endl;
    
    for (int i = 0; i < 10; i++) {
        v.push_back(i);
        cout << "添加 " << i << " 后，容量: " << v.capacity() << endl;
    }
    
    return 0;
}

#include <iostream>
#include <vector>
using namespace std;

// 一个超级简单的分配器，只做一件事：打印日志
template<typename T>
class LogAllocator {
public:
    // 必须的类型定义（STL容器需要）
    using value_type = T;
    
    // 构造函数（可以为空）
    LogAllocator() = default;
    
    // 模板构造函数（用于分配器之间的转换）
    template<typename U>
    LogAllocator(const LogAllocator<U>&) {}
    
    // 最重要的函数：分配内存
    T* allocate(size_t n) {
        cout << "【分配器】分配 " << n << " 个元素，大小: " 
             << n * sizeof(T) << " 字节" << endl;
        return static_cast<T*>(::operator new(n * sizeof(T)));
    }
    
    // 释放内存
    void deallocate(T* p, size_t n) {
        cout << "【分配器】释放 " << n << " 个元素，地址: " << p << endl;
        ::operator delete(p);
    }
};

// 为了让不同元素类型的分配器可以互相转换
template<typename T, typename U>
bool operator==(const LogAllocator<T>&, const LogAllocator<U>&) {
    return true;
}

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

int main() {
    // 使用自定义分配器的vector
    vector<int, LogAllocator<int>> v;
    
    cout << "开始添加元素..." << endl;
    for (int i = 0; i < 5; i++) {
        v.push_back(i * 10);
    }
    
    cout << "vector内容: ";
    for (int x : v) cout << x << " ";
    cout << endl;
    
    cout << "程序结束，vector销毁时会自动释放内存" << endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <string>
using namespace std;

// 统计内存使用量的分配器
template<typename T>
class StatsAllocator {
private:
    static size_t totalAllocated;  // 总共分配了多少
    static size_t totalFreed;      // 总共释放了多少
    static size_t currentUsage;    // 当前使用量
    
public:
    using value_type = T;
    
    StatsAllocator() = default;
    
    template<typename U>
    StatsAllocator(const StatsAllocator<U>&) {}
    
    T* allocate(size_t n) {
        size_t bytes = n * sizeof(T);
        totalAllocated += bytes;
        currentUsage += bytes;
        
        cout << "【分配】" << bytes << " 字节 (当前总使用: " 
             << currentUsage << " 字节)" << endl;
        
        return static_cast<T*>(::operator new(bytes));
    }
    
    void deallocate(T* p, size_t n) {
        size_t bytes = n * sizeof(T);
        totalFreed += bytes;
        currentUsage -= bytes;
        
        cout << "【释放】" << bytes << " 字节 (当前总使用: " 
             << currentUsage << " 字节)" << endl;
        
        ::operator delete(p);
    }
    
    // 静态方法查看统计信息
    static void printStats() {
        cout << "\n=== 内存统计 ===" << endl;
        cout << "总共分配: " << totalAllocated << " 字节" << endl;
        cout << "总共释放: " << totalFreed << " 字节" << endl;
        cout << "当前使用: " << currentUsage << " 字节" << endl;
        cout << "================" << endl;
    }
};

// 初始化静态成员
template<typename T>
size_t StatsAllocator<T>::totalAllocated = 0;
template<typename T>
size_t StatsAllocator<T>::totalFreed = 0;
template<typename T>
size_t StatsAllocator<T>::currentUsage = 0;

// 定义比较操作
template<typename T, typename U>
bool operator==(const StatsAllocator<T>&, const StatsAllocator<U>&) {
    return true;
}

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

// 使用统计分配器的vector
template<typename T>
using StatsVector = vector<T, StatsAllocator<T>>;

int main() {
    cout << "=== 测试1: vector<int> ===" << endl;
    {
        StatsVector<int> v;
        for (int i = 0; i < 10; i++) {
            v.push_back(i);
        }
    }  // v销毁，释放内存
    StatsAllocator<int>::printStats();
    
    cout << "\n=== 测试2: vector<string> ===" << endl;
    {
        StatsVector<string> v;
        v.push_back("hello");
        v.push_back("world");
        v.push_back("C++");
        v.push_back("allocator");
    }
    StatsAllocator<string>::printStats();
    
    return 0;
}