C++ 内存模型（未完。。。）
数据存储
stack栈内存
- 栈内存属于执行期函数，编译时确定大小
- 函数执行时栈空间自动分配，结束时栈空间自动销毁
- 栈对象是线性分配，连续排列，没有内存碎片化效应
- 栈内存具有函数本地性，不存再多线程竞争
- 栈内存有大小限制，可能存在益处，linux默认未8MB，windows默认是1MB
- 栈内存使用对象或引用直接使用，管理复杂度较低
heap堆内存
- 堆内存具有全局共享特点，大小动态变化
- 堆对象分为时手动分配（malloc/new），对象释放时，手动释放内存（delete/free）
- 堆生对象链式分配，非连续排列
- 堆内存全局共享，存在多线程竞争的可能性
- 堆内存的大小没有栈内存严格限制，与机器内存总量和进程寻址空间有关
- 对内存使用指针简介访问，管理复杂度较高
堆与栈
- 栈内存分配快，内存连续，缓存友好，释放快
- 生存中期短，拷贝少（传值、返回值），栈内存性能比堆内存性能好
- 堆内存有更好的灵活性，但性能比栈内存差
- 堆内存再长期运行的程序中有内存碎片化的效应，会造成小快内存无法使用（内存泄漏），降低缓存使用效率
- 堆内存分配需要寻找合适内存大小的内存块，花费时间更多
- 栈对像可以使用RAII和指针以动操作避免拷贝的代价
值语义和引用语义
- 值语义：对象以值的方式直接存储，传值，返回值，拷贝等
- 引用语义：对象已引用或指针的方式间接存储，穿传值，返回值，拷贝传递的是引用或指针
- 值语义没有悬浮指针/引用，没有昂贵的释放操作，没有内存泄漏，没有数据竞争，但是值语义堆大对象拷贝代价高，不能支持虚函数多态
变量初始化
- 使用统一初始化：int a{50}; int a2 = {50};
- 赋值初始化：int a3 = 50;
- 构造初始化：int a4(50);
- 推荐使用统一初始化（列表初始化），可以避免隐式转换
指针容易出现的问题
- 内存泄漏——忘记释放已经申请的内存
- 悬浮指针——使用已经释放的内存，返回栈对象地址
- 重复删除——对已经删除的对象进行二次删除
- 删除非堆对象指针——对栈对像、全局/静态对象地址进行删除
- 使用空指针/使用失效的引用
int* glob;
void process(int* q){
glob = q;
}
void g1(){
int* p = new int{7};
process(p);
delete p;
*glob = 9; //悬浮指针
}
void g2(){
int* p = new int{7};
process(p);
delete p;
delete glob; //重复释放
}
void g3(){
int x = 7;
int* p = &x;
process(p);
delete glob;// 释放栈指针
}
对象内存空间
- 虚函数占用一个指针的大小
- 静态数据成员不参与类堆对象大小的计算
- 初始化顺序按照成员变量声明顺序
- 可以使用#pragma pack(4)来控制对象内存对齐的大小
特殊成员函数与三法则
- 三法则：析构函数、拷贝构造函数、赋值操作符，三者自定义其一，则需要同时定义另外两个（否则编译器自动生成的一般语义有误）
- 使用default让编译器自动生成；使用delete让编译器不要自动生成；
- 编译器自动生成的的拷贝/赋值时按字节拷贝，若出现指针等具有动态数据成员的对象，通常需要自己定义拷贝/赋值/构造行为
- 赋值操作符中的copy和swap是较为好的方法（注意赋值操作中需要避免自我赋值的情况）
- 普通类的成员函数其实相当远一个带有this指针的全局函数。静态成员函数其实不属于类，是一个全局函数，没有this指针；
性能指南
- 如果函数非常小，且时间很敏感，可已将其声明未inline
- 如果函数可能在编译器进行求值，将其声明为constexpr
- 尽量使用类初始化列表对类成员变量进行初始化
- explicit 避免隐式转换
- 使用重载避免引述转换
- 返回值优化（RVO）
vector 与 array
- vector在堆上，array在栈上
- vector使用时，建议设置大小，reserve(1000)，避免vector的内存增长带来的拷贝
class MyClass {
public:
MyClass() = default;//强制生成默认的构造函数
~MyClass() = delete;//强制删除改构造函数
MyClass(const MyClass& tmp) = delete;
MyClass(const MyClass&& tmp) = delete;//移动拷贝
MyClass& operator=(const MyClass& tmp) = delete;
MyClass& operator=(const MyClass&& tmp) = delete;//移动赋值
};
class Point
{
public:
Point(int x, int y) : x_(x), y_(y) {}
int x_;
int y_;
};
class Rectangle
{
public:
Point* left_up_;
int length_;
int width_;
//禁止构造函数隐式转换
explicit Rectangle(int date) {}
Rectangle(int x, int y, int length, int width) : left_up_(new Point(x,y)), length_(length), width_(width) {}
Rectangle(const Rectangle& rect) : length_(rect.length_), width_(rect.width_)
{
if (rect.left_up_ != nullptr)
left_up_ = new Point(*rect.left_up_);
else
left_up_ = nullptr;
}
Rectangle& operator=(const Rectangle& rect)
{
if (this == &rect)
return *this;
Rectangle temp(rect);
swap(left_up_, temp.left_up_);
this->length_ = temp.length_;
this->width_ = temp.width_;
return *this;
}
~Rectangle()
{
delete left_up_;
left_up_ = nullptr;
}
inline friend ostream& operator<<(ostream& os, const Rectangle& rect);
};
ostream& operator<<(ostream& os, const Rectangle& rect)
{
return os << "{" << rect.left_up_->x_ << "," << rect.left_up_->y_ << "," << rect.length_ << "," << rect.width_ << "}" << endl;
}
