三大函数——拷贝构造、拷贝赋值、析构函数

拷贝构造——接受的是自己这种东西

ctor和dtor构造函数和析构函数

字符串有两种：

一种是前面有一个常数，用于记录字符串的长度，此字符串的末尾没有结束符号。

另一种是字符串的末尾有结束符号，字符串的开头没有用于记录字符串长度的常数。

new就是分配内存，分配了一个字符的内存。

分配了一个字符的内存，然后把结束符传进来，这样就形成了一个空字符串

strlen是一个函数，获取字符串的长度（strlen是计算机C语言函数，计算字符串s的（unsigned int型）长度，不包括'\0'在内）你的class里面有指针，你多半是要做动态分配。所以你要在他生命结束前，调用析构函数，把内存释放掉）

拷贝赋值函数

如图中的红框①②③，是要把右手里面的东西拷贝赋值给左边的步骤：

a）清空左边的东西

b）申请和右边一样大的内存空间

c）拷贝

如果没有上面那句检测自我赋值（），会出现如下情况：

检测是否为自我赋值，不仅仅是为了效率，还是为了安全性。

output 函数

为了打印类中的东西，我们要重载操作符 "<<"，由于成员函数有默认this指针，如果将重载"<<"设置成成员函数，那么变量的位置要发生改变，这不符合人们的使用规范，因此，重载"<<"要设置成全局函数。

ostream& operator<<(ostream& os, const String& str)
{
   os << str.get_c_str();
   return os;
}

任何东西，只要你能直接丢给cout，你就直接丢给他输出好了。先看一下整体代码：

#ifndef __MYSTRING__
#define __MYSTRING__

class String
{
public:                                 
   String(const char* cstr=0);                     
   String(const String& str);                    
   String& operator=(const String& str);         
   ~String();                                    
   char* get_c_str() const { return m_data; }
private:
   char* m_data;
};

#include <cstring>

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;
}

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;
}

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

#include <iostream>
using namespace std;

ostream& operator<<(ostream& os, const String& str)
{
   os << str.get_c_str();
   return os;
}

#endif

注意到 get_c_str函数的返回值是char *，刚刚好可以直接给cout进行输出，因此我们写了get_c_str函数来进行输出。

堆栈与内存管理

stack object 的生命周期

static local object

global object 的生命周期

heap object 的生命期

new——先分配内存，后调用构造函数

new的动作分解：

a）调用 operator new 函数来分配内存（operator new 底层调用的是malloc）。对应的，上图分配出

b）第二个动作把我们创建的变量做一个类型转换

c）通过指针调用构造函数Complex（注意：构造函数在类里面，所以是成员函数，会有this指针。谁调用成员函数，this指针就指向谁。因此，上图中的第三步完整的写法应该是如图所示的形式：。

这里的this指针指向了pc）

delete：先调用析构函数，再释放内存

动态分配内存块 in VC

根据上图第一个矩形（debug模式下的情况）：

1、new 一个复数会获得的内存是 8 byte（上图中第一个矩形草绿的部分）。

2、在调试模式下，你会得到灰色的部分，上面每一格是4byte（即），一共 4*8=32个字节。

3、还会得到草绿色矩形下面的那一个 4byte（即）

4、上下两个砖红色的矩形区域是cookie

内存一共需要 8+（32+4）+（4*2）=52，而VC给你分配的内存块一定是16的倍数（现在不提为什么），因此填补了三个深绿色的填补物pad。

看起来分配很浪费，但是这是必要的浪费，因为回收的时候，操作系统需要依据这里的信息来进行回收。

根据上图中第二个矩形（release 模式）：

分配内存8byte，加上上下cookie刚刚好16byte，因此无需调整，无需添加填补物pad。

上下cookie的作用

记录整块给你的内存大小，便于系统回收，让系统知道回收多大内存。

让我们看一下cookie上记录的数字——000000041,对于第一个矩形，内存一共分配了64byte，64的16进制表示是40，而cookie上的数字是41，为什么呢？40借助最后一个bit，最后一位，标志我这块内存是给出去了还是收回来了。这里是给出去了，对于程序来说是获得了，所以最后一位标志位1，因此是41。

同理，对于第二个矩形，系统给出的内存是16byte，16的16进制是10，这里cookie上写的是11，因为这是程序获得的内存。

为什么可以借最后一个bit来标志这一块内存是给出了还是收回了？

因为分配的内存都是16的倍数，16的倍数最后四个bit都是0，我们就可以借一位来表示内存的状态。

为什么array new 要搭配 array delete

分析上图中第一个矩形（debug模型下的array new分配的内存分析）

1、复数申请的数组长度是3，因此申请了三块内存（）

2、在调试模式下要加上那个header，上面是32下面是4（即和）

3、加上向下cookIe（）

4、在VC中（别的编译器不明），会用一个4byte的内存记录数组的长度，即图中的

因此内存分配为 8*3+32+4+4*2+4=72 ，凑16的倍数，所以分配内存为80。

array new要搭配array delete

否则会造成内存泄漏。让我们看看是哪一种内存泄漏

内存泄漏的是动态分配的内存。

写不写 []，清空的内存大小是相等的，因为cookie上有记录。但是不写 [] ,编译器不知道要对每一个对象进行分别的析构。析构的时候，先分别析构各个内存对象，然后再析构母体的那个地方（）。发生内存泄漏的是这里（）

复习string的实现过程

设计一个class，我总是要去思考我需要什么样的数据。由于不知道字符串的长度，所以大部分人设计字符串这种类中的数据都是在里面放一根指针，将来要分配多大的字符串内容，就动态地去分配字符串的大小，用new的方式去动态分配一块内存（在32位的平台里面，一根指针占内存是4字节，所以不管你里面字符有多长，字符串本身就4个字节的内存）