Geekban极客班 第二周

构造函数

inline
String::String(const char* cstr)
{
   if (cstr) {      //判断指针所指是否为空
      m_data = new char[strlen(cstr)+1];  //创建一个空间存放
      strcpy(m_data, cstr);       //拷贝
   }
   else {                   //空字符串处理
      m_data = new char[1]; //分配一个字符
      *m_data = '\0';       //将其设置为空
   }
}

析构函数

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

作用：释放对象在生存期分配的所有资源。
何时会调用析构函数：无论何时一个对象被销毁时，其成员函数被销毁。

为什么带指针的类要有拷贝构造和拷贝赋值

1. 如仅仅使用编译器提供的函数，会造成浅拷贝，即两个对象的指针指向同一块内容，而被拷贝的对象会造成内存泄露。
2. 两个对象的指针指向同一块内容是相当危险的，其中一个对象的修改会造成另一个对象的修改。

拷贝构造

Spring::Spring(const Spring& r) 
{
    m_data = new char[strlen(r.m_data) + 1];
    strcpy(m_data, r.m_data);
}

深拷贝。收到的参数就是其自身类的引用。

拷贝复制

Spring& String::opeator = (const Spring& r)
{
    if(this == &r)          // 检测自我赋值
        return *this;   

    delete []m_data;     //第一步：将自身的空间释放
    m_data = new char[strlen(r.m_data) + 1];   //构建一个与复制的对象相同大小的空间
    strcpy(m_data, r.m_data);   //复制
    return *this;
}

Stack栈 Heap堆

Stack，是存在于某作用域的一块内存空间。例如当你调用函数，函数本身即会形成一个stack用来放置它所接收的参数，以及返回地址。
在函数本体内声明的任何变量，其所使用的内存块都取自上诉stack。
Heap，或称为system heap，是指由操作系统提供的一块global内存空间，程序可动态分配从某中获得若干区块。
用new动态的空间是从Heap中获得，需要自己进行回收处理。
stack objects在作用域结束时被结束，会被自动清理。
stack local objects 如static Complex c2(1,2);作用域结束后还在，直到整个程序结束。

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

String* ps = new String("Hello");
delete ps;

编译器转化为：

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

Static

静态数据： 在内存中有单独一份，只需要一份固定的数据时用。
静态函数： 没有this指针，只能处理静态数据

class Account{
public:
static double m_rate;
static void set_rate(const double& x) {
m_rate=x;
}
double Account::m_rate=8.0;//**静态数据在class外要定义**

调用static函数的用法
（1）通过object调用（2）类名调用

模板

使用类模板时需要指出绑定是什么类型。
使用函数模板时不用指出类型，因为会根据参数的类型进行推导。