内存分配:
静态存储区:
- 局部static对象
- 类的static数据成员
- 定义在任何函数之外的变量
栈区:
- 函数内的非static对象
动态内存分配的方式有:
- new和delete
- 智能指针(shared_ptr、unique_ptr、weak_ptr)
- allocator类
- malloc和free
直接管理内存:
运算符new分配内存,delete释放new分配的内存。
int* p = new int ();//new表达式在自由空间构造一个对象,并返回指向该对象的指针。
delete p;
int* pi = new int[10]();//分配一个10个int的数组,pi指向第一个int。
默认情况下,动态分配的对象是默认初始化的,这意味着内置类型或者组合类型的对象的值是未定义的,而类类型对象将用默认构造函数进行初始化。
用new分配const对象是合法的,但const对象必须进行初始化。
如果一个程序用光了所有可用的内存,new表达式会失败,并抛出bad_alloc异常,该异常可以通过nothrow阻止,阻止异常抛出的new称为定位new。
int* p1 = new int;//如果分配失败,new抛出std::bad_alloc。
int* p2 = new (nothrow)int;//如果分配失败,new返回一个空指针。
delete表达式也执行两个动作:销毁一个给定的指针指向的对象;释放对应的内存。
传递给delete的指针必须指向动态分配的内存,或者是一个空指针,释放一个并非new分配的内存,或者将相同的指针值释放多次,其行为是未定义的。
释放动态数组时,数组中的元素按逆序销毁。
释放一个const动态对象,只要delete指向它的指针即可。
const int* pci = new const int(1024);
delete pci;
直接管理内存容易犯的错:
- 忘记delete内存(内存泄漏)
- 使用已经释放掉的对象
- 同一块内存释放两次
空悬指针/野指针(dangling pointer):指向一块曾经保存数据对象但现在已经无效的内存的指针。
产生原因:指针变量声明时未初始化或者指针被delete或free后未置为nullptr以及指针操作超越了变量的作用范围。
智能指针:
shared_ptr允许多个指针指向同一个对象
unique_ptr“独占”所指向的对象
weak_ptr指向一个shared_ptr管理的对象,它不控制指向对象的生存期。
shared_ptr:
初始化:
shared_ptr<string> p1;//默认初始化的智能指针保存着一个空指针
智能指针的使用方式与普通指针类似。解引用一个智能指针返回它指向的对象,如果在一个条件判断中使用智能指针,效果是检测它是否为空。
if (p1 && p1->empty()) {
*p1 = "hi";//如果p1指向一个空string,解引用p1,将一个新值赋予string。
}
make_shared函数:
类似顺序容器的emplace成员,make_shared用其参数来构造给定类型的对象。
shared_ptr<int> pi = make_shared<int>(42);
引用计数:
每个shared_ptr都有一个关联的计数器,通常称其为引用计数。无论何时我们拷贝一个shared_ptr,或将其作为参数传递给一个函数以及作为一个函数的返回值时,它所关联的计数器就会递增。当我们给shared_ptr赋予一个新值或者是shared_ptr被销毁时,计数器就会递减。当一个shared_ptr的计数器变为0,他就会自动释放自己所管理的对象。
程序使用动态内存的三个原因:
- 程序不知道使用多少个对象(容器类)
- 程序不知道所需对象的具体类型
- 程序需要在多个对象间共享数据
shared_ptr与new的结合:
接受指针参数的智能指针构造函数是explicit的,因此我们不能将一个内置指针隐式转换为一个智能指针,必须使用直接初始化的形式。
shared_ptr<int> p1 = new int(1024);//错误
shared_ptr<int> p1(new int(1024));//正确
如果想用shared_ptr管理动态数组,必须提供自己定义的删除器,并且不支持下标操作。
shared_ptr<int> sp(new int[10],[](int *p){delete [] p ;});
sp.reset();
正确使用智能指针的规范:
- 使用相同的内置指针值初始化(或reset)多个智能指针。
- 不delete get() 返回的指针。
- 不使用get()初始化或reset另一个智能指针。
- 如果你使用get()返回的指针,记住当最后一个对应的智能指针销毁后,你的指针就变为无效了。
- 如果你使用智能指针管理的资源不是new分配的内存,记住传递给它一个删除器。
unique_ptr:
当我们定义unique_ptr时,需要将其绑定到一个new返回的指针上,而且必须采用直接初始化的形式。
由于unique_ptr“独占”它指向的对象,因此unique_ptr不支持拷贝或赋值操作。
虽然我们不能拷贝和赋值unique_ptr,但可以调用release或reset将指针所有权从一个(非const)unique_ptr转移给另一个unique:
unique_ptr<string> p1(new string("first"));
unique_ptr<string> p2(p1.release());//将所有权从p1转向p2,p1被置为空
unique_ptr<string> p3(new string ("second"));
//将所有权从p3转移给p2.
p2.reset(p3.release());//reset释放了p2原来指向的内存。
unique_ptr可以管理动态数组,必须在对象类型后面跟一对空方括号,支持下标操作。
unique_ptr<int[]> up(new int[10]);
up.release();//自动用delete[]销毁其指针。
for(size_t i = 0 ; i != 10 ; i++)
{
up[i] = i;
}
weak_ptr:
weak_ptr不控制所指向的对象的生存期,指向一个由shared_ptr管理的对象。将一个weak_ptr不会改变shared_ptr的引用计数。一旦最后一个指向对象的shared_ptr被销毁,对象就会被释放。
由于对象可能不存在,不能使用weak_ptr直接访问对象,必须调用lock。此函数检查weak_ptr指向的对象是否仍存在。如果存在,lock返回一个指向共享对象的shared_ptr。
可以解决两个shared_ptr互相引用的问题。
allocator类:
将内存分配和对象构造分离开,提供一种类型感知的内存分配方法,他分配的内存是原始的、未构造的。
定义一个allocator对象,必须指明这个allocator可以分配的对象类型。当一个allocator对象分配内存时,它会根据给定的对象类型来确定恰当的内存大小和对齐位置:
allocator<string> alloc;//可以分配string的allocator对象
auto const p = alloc.allocate(n);//分配n个未初始化的string。
auto q = p;
alloc.construct(q++);//*q为空字符串
alloc.construct(q++,10,'c');//*q为cccccccccc
alloc.construct(q++,"hi");//*q为hi
cout<<*p<<endl;//正确:使用string的输出运算符
cout<<*q<<endl;//灾难:q指向未构造的内存
while(q!=p)
alloc.destroy(--q);//释放我们真正构造的string
//destory接受一个指针,对指向的对象执行析构函数。
alloc.deconstruct(p,n);//通过deallocate释放内存。
//传递给deallocate的指针不能为空,它必须指向由allocate分配的内存。而且传递给deallocate的大小参数必须与调用allocated分配内存时提供的大小参数具有一样的值。