C++基础：类与对象(2)，构造函数和析构函数，引用，拷贝构造函数，赋值运算符重载函数

5. 构造函数和析构函数

5.1 构造函数

构造函数可以用来替代C语言中的Create函数，定义即创建

1. 创建对象时自动调用构造函数
2. new方式也可自动调用
3. 构造函数名必须和类名相同
4. 没有返回值类型，也没有返回值
5. 可以有多个构造函数

无参数调用构造函数：顺序表创建

#include <iostream>
using namespace std;

typedef int Element;
class Stack{
   
        Element* data;
        size_t size;
public:
        // 构造函数
        Stack(){
   
                cout << "Stack constructor" << endl;
                data = NULL;
                size = 0;
        }
        /*
        void Create(){
                data = NULL;
                size = 0;
        }
        */
};

int main(){
   
        Stack s;
        Stack* p = new Stack;
}

结果为：

Stack constructor
Stack constructor

有参数调用构造函数：打印复数，做初始化

#include <iostream>
using namespace std;

class Complex{
   
        int real;
        int imag;
public:
        // 构造函数
        Complex(int r,int i){
   
                real = r;
                imag = i;
        }
        /*
        void SetReal(int r){
                real = r;
        }
        void SetImag(int i){
                imag = i;
        }
        */
        void Print(){
   
                cout << real << "+" << imag << "i" << endl;
        }
};

int main(){
   
        Complex c(20,3);
        // Complex c;
        // c.real = 20;
        // c.imag = 3;
        c.Print();
}

结果为：

20+3i

默认构造函数：
类中没有定义任何构造函数，编译器就会自动为该类生成默认构造函数，默认构造函数没有参数

一旦类中定义了一个构造函数，（不带参数的）默认构造函数将消失，如果想用可以再写一个不带参数的构造函数

构造函数的三个作用：

1. 给创建的对象建立一个标识符
2. 为对象数据成员开辟内存空间
3. 完成对象数据成员的初始化

初始化列表

初始化列表：特殊的构造函数

		// 初始化列表
        Complex():real(5),imag(15){
   
        		/*
                real = 5;
                imag = 15;
                */
        }
        // 初始化列表
        Complex(int r,int i):real(r),imag(i){
   
        		/*
                real = r;
                imag = i;
                */
        }

初始化列表 和 普通构造函数 的区别：
初始化列表和 this 指针的结合（重名）：
注意这里必须加this，分清哪个n和哪个n是一个n

class Simple{
   
        int n;
public:
        Simple(int n):n(n){
   
                this->n = n;
        }
};

1 3 5 是一个n ， 2 4 6 是一个n

5.2 析构函数

析构函数可以用来替代C语言中Destory的函数，定义即销毁

1. 对象离开作用域前调用析构函数
2. delete前也可调用
3. 析构函数名必须和类名相同前面再加~
4. 永远没有参数
5. 没有返回值类型，也没有返回值
6. 只能有一个析构函数

注意析构函数调用的时间

#include <iostream>

using namespace std;

typedef int Element;
class Stack{
   
        Element* data;
        size_t size;
public:
        // 构造函数
        Stack(){
   
                cout << "Stack constructor" << endl;
                data = NULL;
                size = 0;
        }
        // 析构函数
        ~Stack(){
   
                cout << "Stack destructor" << endl;
                delete [] data;
                data = NULL;
                size = 0;
        }
        /*
        void Destory(){
                delete [] data;
                data = NULL;
                size = 0;
        }
        */
};

int main(){
   
        Stack s;
        Stack* p = new Stack;
        delete p;
}

结果为：

Stack constructor
Stack constructor
Stack destructor
Stack destructor

自动创建的就会自动销毁，手动创建的就需要手动销毁

默认析构函数：
类中没有定义任何构造函数，编译器就会自动为该类生成默认析构函数

析构函数的作用：
释放对象所申请占有的资源

注意 malloc 和 free 与 new 和 delete 的区别：
malloc 只申请动态内存，不调用构造函数
free 也只是释放内存，也不调用析构函数
new 申请内存空间，调用构造函数
delete 释放内存空间，调用析构函数

6. 引用

引用用来替代C语言中指针

引用和指针的区别 / 引用的本质：

#include <iostream>
using namespace std;

int main(){
   
        int n = 10;
        int* p = &n;      // 指针，相当于p指向n
        cout << "*p:" << *p