STL学习_SGI空间配置器_第一级配置器源码分析

    这篇文章自己总结了下自己对于STL标准库中的SGI配置器的第一级配置器的源码分析，主要是想将自己上篇的理论知识具体化，

#ifndef _STL_ALLOC1_H
#define _STL_ALLOC1_H

#include <iostream>
#include <stdlib.h>
#include <exception>
#include <malloc.h>
using namespace std;

#if 1
#include <new>
#define __THROW_BAD_ALLOC cerr<<"Out of memory"<<endl;exit(1)
#elif !defined(__THROW_BAD_ALLOC)
#include <iostream.h>
#define __THROW_BAD_ALLOC cerr<<"out of memory"<<endl;exit(1)
#endif

template<int inst>
class __malloc_alloc_template{

private:
    //以下函数用来处理内存不足的情况
    static void *oom_malloc(size_t);
    static void *oom_realloc(void *, size_t);
    static void (*__malloc_alloc_oom_handler)();

public:
    static void *allocate(size_t n)
    {
        void *result;
        result = malloc(n);
        if(0 == result){
            result = oom_malloc(n);
        }
        return result;
    }

    static void *reallocate(void *p, size_t, size_t new_sz)
    {
        void *result = realloc(p, new_sz);
        if(0 == result){
            result = oom_realloc(p, new_sz);
        }
        return result;
    }

    static void *deallocate(void *p, size_t)
    {
        free(p);
    }
    //设置异常处理函数
    //SGI不能直接使用c++的set_new_handler()函数，必须仿真一个类似的set_malloc_handler()
    //set_malloc_handler()这个函数传入的参数为[void (*f)()]是个函数指针，指的是下面写的程序test.cpp中
    //的my_new_handler()这个函数
    static void (*set_malloc_handler(void (*f)()))()
    {
        void (*old)() = __malloc_alloc_oom_handler;
        __malloc_alloc_oom_handler = f;
       return (old);
    }
};

//这里将__malloc_alloc_oom_handler()设置为0，有待客户设置自己想要的异常处理函数。
template<int inst>
void (*__malloc_alloc_template<inst>::__malloc_alloc_oom_handler)() = 0;

//当allocate()申请空间失败的情况下会调用oom_malloc()这个函数，这个函数会不断的尝试空间的释放，
//和客户空间的申请，如果客户自己定义了内存异常处理函数（my_malloc_handler()）则当内存申请失败
//会调用异常处理函数，如果客户没有自己定义异常处理函数，则抛出一个异常。
template<int inst>
void *__malloc_alloc_template<inst>::oom_malloc(size_t n)
{
    void (*my_malloc_handler)();
    void *result;
    for(;;){
        my_malloc_handler = __malloc_alloc_oom_handler;
        //如果客户没有设置异常处理函数
        if(0 == my_malloc_handler){
            __THROW_BAD_ALLOC;//抛出一个异常，并利用exit(1)函数硬生生的终止程序
        }
        //如果设置了，则调用客户自己定义的异常处理函数
        (*my_malloc_handler)();
        result = malloc(n);
        if(result){
            return result;//空间申请成功返回内存指针
        }
    }
}

template<int inst>
void *__malloc_alloc_template<inst>::oom_realloc(void *p, size_t n)
{
    void (*my_malloc_handler)();
    void *result;
    for(;;){
        my_malloc_handler = __malloc_alloc_oom_handler;
        if(0 == my_malloc_handler){
            __THROW_BAD_ALLOC;
        }
        (*my_malloc_handler)();
        result = malloc(n);
        if(0 == result){
            return result;
        }
    }
}

typedef __malloc_alloc_template<0> malloc_alloc; 

#endif

测试程序：

#include "stl_alloc1.h"

void my_new_handler()
{
    cout<<"out of memory"<<endl;
}

int main(int argc, char **argv)
{
    __malloc_alloc_template<0>::set_malloc_handler(my_new_handler);
    int *p = (int *)__malloc_alloc_template<0>::allocate(sizeof(int) * 10);
    *p = 100;
    cout<<*p<<endl;
    __malloc_alloc_template<0>::deallocate(p, 0);
    return 0;
}

申请的空间大小为4*10，结果系统能够给客户申请这么大的空间申请成功，如果改成sizeof(int)*100000000000000即申请一个很大的空间，系统就没有足够大的空间供客户申请，则由于malloc()申请不到空间，则会调用oom_alloc()函数，但是由于客户需求的空间太大oom_alloc()也申请不到空间，则oom_alloc()函数内部处于死循环阶段不断的调用异常处理函数my_new_handler()，不断的进行空间的申请，所以结果是屏幕上不断的打印out of memory