Boolan微专业-面向对象高级编程学习笔记（Week02）

Class with pointer member(stirng)

1. Big Three

• 拷贝构造 String(const String& str);
• 拷贝赋值 String& operator=(const String& str);
• 析构函数 ~String();

构造函数和析构函数

• 构造函数
  • String(const char* cstr = 0);
  • 字符串构造要注意检查是否为 nullptr
• 析构函数
  • 带有指针的 Class 多半会动态分配内存，因此在析构函数中要主动将动态分配的内存 delete 掉

  • inline String::~String(){
      delete[] m_data;
    }
    

• Class with pointer members 必须要有 copy ctor 和 copy op=
  • 默认的copy ctor 和 copy op= 只会进行浅拷贝，会导致两个指针指向同一内存块，形成 alias 和 memory leak
  • 拷贝构造&拷贝赋值

拷贝构造

• inline String::String(const String& str){
    m_data = new char[ strlen(str.m_data) + 1 ];
    strcpy(m_data, str.m_data);
  }
  

• String s2(s1) <===> String s2 = s1 两者调用的都是拷贝构造函数

拷贝赋值

• inline String& String::operator=(const String& str){
    if (this == &str)
      return *this;           // 检测自我赋值
    delete[] m_data;
    m_data = new char[ strlen(str.m_data) + 1 ];
    strcpy(m_data, str.m_data);
    return *this;
  }
  

• 步骤：
  1. 先释放自己 delete[] m_data
  2. 分配足够的内存 m_data = new char[ strlen(str.m_data) + 1 ];
  3. 拷贝数据 strcpy(m_data, str.m_data);
• 要点：
  • 返回类型要是String&,用于s1 = s2 = s3的使用情景
  • 一定要检测自我赋值,否则会造成undefined behavior
  • self assignment

---

2. Stack(栈) 与 Heap(堆)

Stack

• Complex c1(1,2);
• 内存由编译器在需要时自动分配和释放。通常用来存储局部变量和函数参数。（为运行函数而分配的局部变量、函数参数、返回地址等存放在栈区）。
• 栈运算分配内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
• Stack 对象的生命在作用域 Scope 结束之际结束，自动调用其析构函数

Heap

• Complex* p = new Comples(3);
• System Heap, 由操作系统提供的一块 global 内存空间，程序可动态分配从中获得若干区块
• 要配合使用 delete 或 delete[] 进行释放,否则会造成内存泄漏

其他内存块 [参考]

• 自由存储区：就是那些由malloc等分配的内存块，他和堆是十分相似的，使用free来释放内存
• 全局/静态存储区：全局变量和静态变量被分配到同一块内存中(在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区)
• 常量存储区：一块比较特殊的存储区，里面存放的是常量，不允许修改。

对象

• Stack Objects
  1. Complex c1(1,2);
  2. 生命在作用域(Scope)结束之际结束
  3. 编译器自动调用其析构函数，因此又称为 auto object
• Static Stack Objects
  1. static Complex c2(1,2);
  2. 生命在作用域(Scope)结束之后仍存在，直至整个程序结束
• Global Object
  1. Complex c3(1,2);
int main(){
...
}
  2. 生命在作用域(Scope)结束之后仍存在，直至整个程序结束
• Heap Objects
  1. Complex* p = new Complex;
  2. 生命在它被 delete 之际结束，调用其析构函数
  3. 若未 delete 则会造成 memory leak(指针p的生命已经结束了，但所致的heap object仍存在)

---

3. new & delete

new 与 构造

• 先分配 memory, 再调用 ctor

• Complex* pc = new Complex(1,2); ==>

  void* mem = operator new(sizeof(Complex)); // 分配内存，内部调用 malloc(n)
  pc = static_cast<Complex*>(mem);           // 转型
  pc->Complex::Complex(1,2);                 // 调用构造函数
  

delete 与 析构

• 先调用 dtor, 再释放 memory

• delete pc; ==>

  Complex::~Complex(pc);                    // 析构函数
  operator delete(pc);                      // 释放内存，内部调用 free(pc)
  

内存详情

Single Object

• Single Object Memory In VC

• 灰色部分为Debug模式额外添加的信息

• 绿色部分为对象数据所占空间，此处需要满足内存4字节对齐（青绿色标出）

• 内存块收尾为标记为，其值代表整个内存块大小。最后1位用于指示内存块的用途，1：送出 0：回收

Array Object

• Array Object Memory In VC

Array New 一定要搭配 Array Delete

• Array New
• Array new 分配的内存的使用 delete 释放时，编译器仅会施放申请的内存，且只调用1次析构函数，会导致部分对象未正确析构

4. Static

Static Data Member

• 将数据与对象分离，与类绑定
• 一定要在类外初始化（真正的分配内存），赋不赋值均可
  • class Account {
public:
static double m_rate;
static void set_rate(const double& x) { m_rate =x; };
}
double Accont::m_rate = 8.0;

Static Function Member

• 用于操作Static Data
• 调用方式：
  • 通过 object 调用 Accout a; a.set_rate(7.0);
  • 通过 class name 调用 Account::set_rate(5.0);

Singleton(单例) [参考] --- 把 ctor 放在 private 区

class Singleton {
  public:
    static Singleton& Instance() {
    static Singleton theSingleton;
      return theSingleton;
  }

/* more (non-static) functions here */

private:
  Singleton();                            // ctor hidden
  Singleton(Singleton const&);            // copy ctor hidden
  Singleton& operator=(Singleton const&); // assign op. hidden
  ~Singleton();                           // dtor hidden
};

• 在 Instance() 调用前，不会存在 theSingleton对象，没有内存的浪费

概念辨析

• Static 全局变量 vs. 普通全局变量
  • 全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。 这两者在存储方式上并无不同
  • 非静态的全局变量在各个源文件中都是有效的
  • 而静态全局变量则限制了其作用域， 只在定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它
  • 全局变量改为静态后改变了它的作用域
• Static 局部变量 vs. 普通局部变量
  • Static 局部变量存储在静态区，生命直至整个程序结束
  • 普通局部变量存储在栈区，生命仅在 Scope 内有效
  • 局部变量改为静态后改变了它的生命期