目录
基础概念
内存布局
分配方式
实现
1.new和delete
2.利用空间配置器alloc
3.用malloc和free
4.静态内存分配
基础概念
在讲内存分配之前，先对一些基础概念进行阐述，以便能更好的讨论问题
内存布局
代码编译为可执行程序后运行占用的内存可以分为以下几个区域：
1.栈区（stack) : 由编译器自动分配释放，用于存放函数的参数值，局部变量的值等；在一个进程中，位于用户虚拟地址空间顶部的是用户栈，编译器用它来实现函数的调用；栈上的内存在函数返回时就会自动释放；栈区的内存地址延伸方式从高地址向地址；栈内存的大小通常是有限的，所以大量使用可能导致栈溢出。
2.堆区（heap) : 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS（操作系统）回收；堆可以动态地扩展和收缩，注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。
3.全局区（静态区、static）: 全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统释放。
4.文字常量区 : 常量字符串就是放在这里的，程序结束后由系统释放。
5. 程序代码区 : 存放函数体的二进制代码，代码里面的全局函数和类成员函数编译后就是存在这个区域。
一个可执行程序，在不运行时占用磁盘空间的是全局区、文字常量区和程序代码区，运行后栈区和堆区在内存里面才划分出来工作。下面是区域划分图：
实例分析
int g_a=0; //全局初始化区
static int g_b = 0; //全局变量，static限制了使用区域
char *g_p1; //全局未初始化区
static void func(int x, int y) //x,y是形参，栈区
{
static int x1 =0；//局部（静态）初始化区
int x2 = 0; //局部变量，栈区
}
int main()
{
int x; //局部变量，存放在栈区
char s[]="abc"; //局部变量，栈
char *p1; //局部变量，栈
char *p2="abcdef"; //"abcdef/0"在常量区，p3在栈上。
p1 = (char *)malloc(23); //分配得来得23和25字节的区域就在堆区
strcpy(p1,"abcdef"); //"abcdef\0"放在常量区，编译器可能会将它与p2所指向的"abcdef" 优化成一个地方
int* p4 = new int(2); //p4是局部变量，存放在栈区，p4指向的内存是堆区
} 分配方式
C/C++内存分配方式有3种：
1.从静态存储区域分配: 是在程序编译和链接时就确定好的内存；这些内存在程序整个运行期间都存在，如全局变量，static变量等。
2.在栈上创建：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放，栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限，如数组，局部变量，形参。
3.从堆上分配：亦称动态内存分配 ，是在程序加载、调入、执行的时候分配/回收的内存；程序在运行的时候用 malloc 或 new 申请任意多少的内存，程序员自己负责在何时用 free 或 delete 释放内存。动态内存的生存期由程序员决定 ，使用非常灵活，但如果在堆上分配了空间，就有责任回收它，否则运行的程序会出现内存泄漏，频繁地分配和释放不同大小的堆空间将会产生堆内碎块。
实现
1.new和delete
在C++里面这种方式是用的最多的，代码如下：
template <class T>
struct CreateUsingNew
{
template <typename... Args>
static T* Create(Args&&... args)
{ return new T(std::forward<Args>(args)...); }
static void Destroy(T* p)
{ delete p; }
};2.利用空间配置器alloc
在STL中空间配置器的4个函数：
内存的配置：alloc::allocate();
对象的构造：alloc::construct();
对象的析构：alloc::destroy();
内存的释放：alloc::deallocate();利用空间分配器分配内存的代码如下：
template<template<class> class Alloc>
struct CreateUsing
{
template <class T>
struct Allocator
{
static Alloc<T> allocator;
template <typename... Args>
static T* Create(Args&&... args)
{
return new (allocator.allocate(1)) T(std::forward<Args>(args)...);
}
static void Destroy(T* p)
{
//allocator.destroy(p);
p->~T();
allocator.deallocate(p,1);
}
};
};STL中容器默认空间分配器为std::allocator<_Tp>，内存分配和释放的接口allocate和deallocate内部实现只是将::operator new和::operator delete进行封装，没用做特殊处理；如果还想深入了解STL的空间配置器的相关内容，可以查阅我的博客深入理解STL空间分配器(一)-CSDN博客、深入理解STL空间分配器(二)-CSDN博客、深入理解STL空间分配器(三)-CSDN博客、深入理解STL空间分配器(四)-CSDN博客。
3.用malloc和free
C语言的传统方式分配和释放内存，代码如下：
template <class T>
struct CreateUsingMalloc
{
template <typename... Args>
static T* Create(Args&&... args)
{
void* p = std::malloc(sizeof(T));
if (!p) return 0;
return new(p) T(std::forward<Args>(args)...);
}
static void Destroy(T* p)
{
p->~T();
std::free(p);
}
};4.静态内存分配
代码如下：
template <class T>
struct CreateStatic
{
#ifdef _MSC_VER
#pragma warning( push )
#pragma warning( disable : 4121 )
// alignment of a member was sensitive to packing
#endif // _MSC_VER
union MaxAlign
{
char t_[sizeof(T)];
short int shortInt_;
int int_;
long int longInt_;
float float_;
double double_;
long double longDouble_;
struct Test;
int Test::* pMember_;
int (Test::*pMemberFn_)(int);
};
#ifdef _MSC_VER
#pragma warning( pop )
#endif // _MSC_VER
template <typename... Args>
static T* Create(Args&&... args)
{
static MaxAlign staticMemory_;
return new(&staticMemory_) T(std::forward<Args>(args)...);
}
static void Destroy(T* p)
{
p->~T();
}
};上面的例子都用到了std::forward，实现了构造函数参数的完美转发，它的用法可以参考博客C++之std::forward-CSDN博客
