C++学习笔记总结练习：内存分配器编程实现

内存分配器练习

C++内存分配器是用于管理程序运行时内存的工具。它负责分配和释放内存，以满足程序在运行过程中的动态内存需求。在C++中，有几种内存分配器可供选择，包括操作系统提供的默认分配器、自定义分配器和第三方库提供的分配器。

1. 默认分配器：
   默认情况下，C++使用操作系统提供的默认分配器来分配和释放内存。这些分配器通常是基于堆的，使用malloc()和free()等函数来分配和释放内存。默认分配器的优点是简单易用，但在某些情况下可能会存在性能问题。

2. 自定义分配器：
   C++允许开发人员自定义内存分配器，以满足特定的需求。通过重载new和delete运算符，可以实现自定义的内存分配和释放逻辑。自定义分配器可以根据应用程序的特点进行优化，例如使用内存池、缓存等技术来提高性能和效率。

3. 第三方库提供的分配器：
   除了默认分配器和自定义分配器，还有一些第三方库提供了高级的内存分配器。这些分配器通常具有更高的性能和更好的内存管理能力。例如，Google的tcmalloc、Facebook的jemalloc等都是常用的第三方内存分配器。

在使用内存分配器时，需要注意以下几点：

• 内存泄漏：确保在不再使用内存时及时释放，避免内存泄漏问题。
• 内存碎片：频繁的内存分配和释放可能导致内存碎片问题，影响程序性能。可以使用内存池、缓存等技术来减少内存碎片。
• 多线程安全：如果程序涉及多线程操作，需要确保内存分配器的线程安全性，避免竞争条件和数据损坏。
• 性能优化：根据应用程序的特点和需求，选择合适的内存分配器以提高性能和效率。

总结起来，C++内存分配器是用于管理程序运行时内存的工具。开发人员可以使用默认分配器、自定义分配器或第三方库提供的分配器来满足程序的内存需求。在使用内存分配器时，需要注意内存泄漏、内存碎片、多线程安全和性能优化等问题。

#ifndef __JJALLOC__
#define __JJALLOC__
#endif
#include<new> // for placement new
#include<iostream> //for cerr
#include<cstddef>  //for ptrdiff_t
#include<cstdlib> // for exit()
#include<climits> // for UINT_MAX
namespace my{
    // 申请内存空间。调用operator new 。
    // T*参数是为了注册模板类型T
    template<class T>
    inline T* _allocate(ptrdiff_t size, T*){
        //set_new_handler(0);
        T* tmp = (T*)(::operator new)((size_t)(size * sizeof(T)));
        if (tmp == 0){
            std::cerr << "out of memory" << std::endl;
        }
        return tmp;
    }

    // 释放内存空间。调用operator delete
    template<class T>
    inline void _deallocate(T* buffer){
        ::operator delete(buffer);
    }

    // 创建内存对象。调用placement new
    template<class T1,class T2>
    inline void _construct(T1 *p, const T2 &value){
        new (p)T1(value);
    }
    // 通过查询了解到这个操作叫做placement new，就是在指针p所指向的内存空间创建一个T1类型的对象，但是对象的内容是从T2类型的对象转换过来的（调用了T1的构造函数，T1::T1(value)）。
    // 就是在已有空间的基础上重新调整分配的空间，类似于realloc函数。这个操作就是把已有的空间当成一个缓冲区来使用，这样子就减少了分配空间所耗费的时间，因为直接用new操作符分配内存的话，在堆中查找足够大的剩余空间速度是比较慢的。

    // 释放内存对象。调用析构函数。
    template<class T>
    inline void _destroy(T* ptr){
        ptr->~T();
    }


    template <class T>
    class allocate{
    public:
        typedef T value_type;
        typedef T* pointer;
        typedef const T* const_pointer;
        typedef T& reference;
        typedef const T& const_reference;
        typedef size_t size_type;
        typedef ptrdiff_t difference_type;

        // template<class U>
        // struct rebind{
        //     typedef allocator<U> other;
        // };

        pointer alloc(size_type n, const void * hint = 0){
            return _allocate((difference_type)n, (pointer)0);
        }
        void deallocate(pointer p, size_type n){
            _deallocate(p);
        }

        void construct(pointer p, const_reference value){
            return _construct(p, value);
        }

        void destroy(pointer p){
            _destroy(p);
        }
        pointer address(reference x){
            return (pointer)&x;
        }
        pointer const_address(const_reference x){
            return (const_pointer)&x;
        }

        size_type max_size()const{
            return (size_type)(UINT_MAX / sizeof(T));
        }
    };
}
#include<iostream>
using namespace std;
int main(){
    my::allocate<int> al;
    int * ptr = al.alloc(10);
    cout<<"alloc:"<<*ptr<<"\t"<<*(ptr+1)<<endl;
    al.construct(ptr,123);
    cout<<"construct:"<<*ptr<<"\t"<<*(ptr+1)<<endl;
    al.destroy(ptr);
    cout<<"destroy:"<<*ptr<<"\t"<<*(ptr+1)<<endl;
    al.deallocate(ptr,100);
    cout<<"deallocate:"<<*ptr<<"\t"<<*(ptr+1)<<endl;
    int size = al.max_size();
    cout<<"size:"<<size<<endl;

    int* b=new int[3];
    cout<<*b<<endl;
    new (b)int(999);
    cout<<*b<<endl;
    cout<<*(b+1)<<endl;
}