第七节 三大函数：拷贝函数，拷贝赋值，析构

今天开始学习另一个经典类，String（仅从三大函数的角度）。

• 构造函数
• 拷贝构造函数
• 拷贝赋值函数
• 析构函数

大家都知道，我们在创建实例的时候，编译器会自动调用class中的构造函数对实例进行初始化，而在销毁实例或生命周期结束时会自动调用其析构函数来清理内存。那么拷贝构造函数与拷贝赋值函数是什么呢？它们的作用是？

先来看一段String类接口：

class String
{
private:
    char *m_data;
public:
    String(const char* cstr=0);//构造函数
    String(const String& str);//拷贝构造函数
    String& operator=(const String&str);//拷贝赋值函数
    ~String();//析构函数
    char* get_c_str() const{return m_data};
};

再来看下面的代码：

int main()
{
    String s1();//调用构造函数
    //String S1;//调用构造函数
    String s2("hello");//调用构造函数
    String s3(s1);//调用拷贝构造函数
    String s4=s1;//调用拷贝构造函数
    s4=s2;//拷贝赋值函数
    return 0;
}

看了上面的代码，是不是对四个函数有了基本的印象呢，下面我们来深入学习。

构造函数/析构函数

inline
String::String(const char* cstr=0)//用来创建无参实例或以字符串("aaaa"或char[5])为参数的实例
{
    if(cstr)//有参
    {
        m_data=new char[strlen(cstr)+1];//为m_data开辟空间，大小为参数长度+1(存放'\0')
        strcpy(m_data,cstr);//赋值
    }
    else//无参
    {
        m_data=new char[1];//开辟大小为1的空间，存放'\0'
        *m_data='\0';
    }
}//构造函数
inline 
String::~String()
{
    delete[] m_data;//释放内存，注意用[]
}//析构函数

int main()
{
    String* p=new String("hello");//调用构造函数
    delete p;//调用析构函数
    return 0;
}//测试函数

比较中规中矩的用法。

拷贝构造函数/拷贝赋值函数/析构函数

inline
String::String(const String& str)
{
    m_data=str.m_data;
}//浅拷贝构造函数（编译器自带的那一套）

String s1="hello world";
String s2=s1;

我们知道，在执行String s1="hello world";String s2=s1;这样的操作时，编译器会调用默认拷贝构造函数，然而这种默认的拷贝构造函数只是单纯的将s1中的数据一个bit一个bit的复制过去，是一种浅拷贝，当我们的class中有point成员时，这种浅拷贝会使s1,s2中的两个point指向同一块内存，这是很危险的。这时，我们需要为编译器提供一个新的、深拷贝的拷贝构造函数。

inline
String::String(const String& str)
{
    m_data=new char[strlen(str.m_data)+1];
    strcpy(m_data,str.m_data);
}//深拷贝构造函数（无内存问题）

以上为拷贝构造函数只能解决在新建实例时对class中point成员指向问题，在实例已经创建完成后的赋值动作，同样会存在指针指向相同内存的问题，我们需要通过重载操作符'='来解决这个问题，即拷贝赋值函数。

inline
String& String::operator =(const String& str)
{
    if(this==&str)//检测自我复制(self assignment)
        return *this;
    delete[] m_data;//原理内存（原内存长度不可更改）
    m_data=new char[strlen(str.m_data)+1];//重新开辟长度适当的空间
    strcpy(m_data,str.m_data);//赋值
    return *this;//返回this
}//拷贝赋值函数

String s1("hello world");
String s2;
s2=s1;//调用拷贝赋值函数

以上就是String中的big three。

最后再来重载一下'<<'方便输出String实例

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

{
    String s1("hello ");
    cout<<s1;
}

第八节 堆，栈与内存管理

• 栈（Steak）

是存在于某作用域(scope)的一块内存空间(memory space)。

• 堆（Heap）

也成system heap,是由操作系统提供的一块global内存空间，程序可以动态分配(dynamic allocated)从其中获得若干区块(blocks)。

class Complex{...};
...
{
    Complex c1(1,2);//分配栈空间
    Complex* p=new Complex(3);//动态分配堆空间
}

static object与global object两种都在main之前存在，（联想构造函数）在程序结束时销毁（析构函数）。

new：先分配memory，再调用ctor

Complex* pc=new Complex(1,2);
//编译器转化为
void* mem=operator new(sizeof(Complex));//分配内存（大小决定于class数据类型）,内部会调用malloc(n)
pc=static_cast<Complex*>(mem);//转型
pc->Complex::Complex(1,2);//构造函数

delete:先调用dt,在释放memory

String* ps=new String(Hello);
delete ps;
//编译器转化为
String::~String(ps);//调用析构函数，杀掉class中动态分配的内存
operator delete(ps);//释放内存，内部调用free(ps)，free(ps)用来杀掉class本身(即数据成员);

小结：构造函数与析构函数的作用是初始化和清理class中动态分配的内存，真正执行创建和销毁object的操作是malloc(),与free()

动态分配所得的内存块,in VC

我们创建一个Complex类（双double成员），一般会认为被动态分配8个bit。

但实际上，在VC中的情况是这样的(VC中每个内存块一定是16的倍数)：

|Complex

|00000041(Cookies)
|Debugger Header(debug,32+4bit)
|Complex Object(data,8bit)
|00000000(pad,16bit)
|00000041(Cookies)
8+(32+4)+(4*2)

->52

->64（debug模式下）

| 00000011(Cookies)

| Complex(data,8bit)
| 00000011(Cookies)
8+(4*2)

->16

以上Debug标注为在调试模式下所分配的内存。而Cookies用来记录分配内存的大小，上例中分别为00000040与00000010,利用最后一位记录是否已经分配,分配后则为00000041与00000011。

以上为Complex object,String object与其结构相似在这就不多做赘述。

下面分析一下动态分配所得的array：

| Complex[3]

| 51h(Cookies)
| Debugger Header(debug,32+4bit)
| 3(4bit)
| double(24bit)
| 00000000(pad,8bit)
| 51h(Cookies)
(8 *3)+(32+4)+(4 *2)+4

->72

->80

非debug模式下为：

(8 *3)+(4 *2)+4

->36

->48

| String[3]

| 41h(Cookies)
| Debugger(32+4bit)
| 3
| pointer(12bit)
| 00000000(pad,4bit)
| 41h(Cookies)

(4 *3)+(32+4)+(4 *2)+4

->60

->64

array new一定要搭配array delete

String* p=new String[3];
delete[] p;//唤起3次dtor
//只有加"[]"编译器才会明白要清理的对象是一个数组，才会读取3,唤起三次dtor(自写，处理class中动态分配内存)

如果例子中是Complex类，则不论是不是数组使用delete p都没有问题，因为不存在类中动态分配内存，所以不需要dtor，只要调用free()清理double即可，但是为了规范，方便记忆，单个object使用delete,数组使用delete[]。

[]的本质是命令编译器读取pointer(12bit)或double(23bit)上方的用来记录数组长度的内存来获取数组长度，并唤起dtor该长度的次数。

第九节 扩展补充：类模板，函数模板，及其他

补充：static

1. 通常100个实例就有100组数据，而函数保存在代码区，只有一份。一份函数处理多组数据，靠this指针。调用方法：c1.real()->complex::real(&c1);将地址传入this用来识别具体是哪一组数据。
2. static修饰的实例类作用域为全局，在程序结束时销毁。
3. static会使数据与函数与类分离，在内存中单独存储，且只有一份。因为没有this指针，所以static函数只能处理static数据。
4. 类中声明静态实例不会分配内存（声明）。在类外初始化时分配（定义）。
5. 静态函数的调用方法：（1）通过实例调用。例:Account a;a.set();（2）通过class name来调用。例：Account::set;(与临时变量语法类似)。

补充：把ctors放在private中

单例模式(Singleton)

class A
{
public:
    static A& getInstance(return a;);//对外窗口
    setup(){...}
private:
    A();//构造函数
    A(const A& rhs);//拷贝构造函数
    static A a;//实例
};

然而上述方法还不够完美，实例a在object创建时就已经存在，有些浪费空间，最好是在使用时才创建。只需要将创建实例的过程放到对外窗口中即可，只有外界通过窗口访问时再创建。

class A
{
public:
    static A& getInstance();
    setup(){...}
private:
    A();
    A(const A& rhs);
    ...
};
A& A::getInstance()
{
    static A a;
    return a;
}

解析：实现单例要解决两个问题：

（1）控制权限，不允许到处创建实例。解决方法：将构造函数放在private中，则只允许在类内创建实例。

（2）控制数量，只允许创建一个实例。解决方法：使用static修饰实例。

补充：cout

在这里先抛出一个问题，为什么cout可以接受可种各样的数据并弹出呢？

cout属于_IO_ostream_withassign类，继承于ostream，我们来看一下ostream的定义。

class ostream:virtual public ios
{
public:
    ostream& operator<<(char c);
    ostream& operator<<(unsigned char c){return(*this)<<(char)c;}
    ostream& operator<<(signed char c){return (*this)<<(char)c;}
    ostream& operator<<(const char *s);
    ostream& operator<<(const unsigned char *s){return (*this)<<(const char*)s;}
    ostream& operator<<(const signed char *s){return (*this)<<(const char*)s;}
    ostream& operator<<(const void *p);
    ostream& operator<<(int n);
    ostream& operator<<(unsigned int n);
    ostream& operator<<(long n);
    ostream& operator<<(unsigned long n);
    ...
}

不难发现ostream中对操作符"<<"进行了大量重载，正因如此cout才可以接收各种各样的数据类型。

补充：类模板(class template)

适用情况：相同操作，不同数据

template<typename T>
class A
{
private:
    T data;
public:
    A();
    T get(return data);
};

int main()
{
    A<int> a;//绑定
    cout<<a.get()<<endl;
    return 0;
}

在定义类时不指定数据类型，而是使用一个符号T来代替，之后在使用时绑定类型。

补充：函数模板(function template)

顾名思义使用在非类成员函数的模板。

template<class T>
T min(T& a,T& b)
{
    return a>b?b:a;//T的类型会影响具体调用那一种'>'操作符重载
}

int main()
{
    int a,b;
    cin>>a>>b;
    cout<<min(a,b);
    return 0;
}

在调用使用模板的函数时编译器会进行“引数推倒（argument deduction）”，即利用传进的实参在决定T类型，并推出返回类型或重载类型。

补充：命名空间(namespace)

以标准库为例，标准库中所有的命名都被包含在了命名空间std中，使用的方法有几种：

1. using namespace std;cin,cout;
2. using std::cout;std::cin,cout;
3. (NONE);std::cin,stu::cout;

更多细节深入

一下是不包含在课程中的内容，顺便记录一下。

1. operator type()const;//转换函数
2. explicit complex(...):initialization list{}
3. pointer-like object
4. function-like object
5. Namespace
6. template specialization
7. Standard Library
8. variadic template(c11)
9. move ctor(c11)
10. Rvalue reference(c11)
11. auto(c11)
12. lambda(c11)
13. range-base for loop(c11)
14. unordered containers(c11)
    ...

今天就到这吧。。。