目录
1.类的默认成员函数
2.构造函数
1.全缺省构造函数
2.第7点中的对自定义类型的成员变量构造（调用编译器自动生成的默认构造函数）
3.析构函数
4.拷贝构造函数
5.运算符重载
1.概念
2.赋值运算符重载
6.const成员函数
1.类的默认成员函数
默认成员函数就是用户没有显式实现，编译器会⾃动⽣成的成员函数称为默认成员函数。⼀个类，我们不写的情况下编译器会默认⽣成以下6个默认成员函数，需要注意的是这6个中最重要的是前4个，最后两个取地址重载不重要，我们稍微了解⼀下即可。
2.构造函数
构造函数是特殊的成员函数，它的作用是初始化对象。构造函数的本质是要替代我们以前Date类中写的Init函数的功能，构造函数自动调用的特点就完美的替代了Init。
1.全缺省构造函数
由于全缺省的构造函数适用面更广，所以我们写个全缺省的构造函数。
class Date
{
public:
Date(int year=2024,int month=9,int day=15)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << '/' << _month << '/' << _day << endl;
}
private:
int _year;
int _month;
int _day;
};Date d1;
d1.Print();结果：
通过结果我们可以看出d1这个对象在定义时就已经初始化完成了，而它的初始化就是由我们所写的构造函数来完成的。
2.第7点中的对自定义类型的成员变量构造（调用编译器自动生成的默认构造函数）
typedef int STDataType;
class Stack
{
public:
Stack(int n = 4)
{
_a = (STDataType*)malloc(sizeof(STDataType) * n);
_capacity = n;
_top = 0;
}
private:
STDataType* _a;
int _capacity;
int _top;
};
// 两个Stack实现队列
class MyQueue
{
public:
//编译器默认⽣成MyQueue的构造函数调⽤了Stack的构造，完成了两个成员的初始化
private:
Stack pushst;
Stack popst;
};
从上图中，我们可以看出在我们用队列这个类创建对象之后，它是调用了栈那个类中的默认构造函数，因为我在队列的类中并没有写构造函数，调用的是编译器的默认构造函数，而编译器在队列中的默认构造函数就是调用了栈这个类的默认构造函数（如果栈中没有默认构造函数，编译器会报错，下面举个例子）。
例如：假设我把上面的代码中的默认构造函数改成普通的构造函数的话，此时栈这个类中是没有默认构造函数的，故队列在创建对象时会报错。
3.析构函数
typedef int STDataType;
class Stack
{
public:
Stack(int n = 4)
{
_a = (STDataType*)malloc(sizeof(STDataType) * n);
_capacity = n;
_top = 0;
}
~Stack()
{
cout << "~Stack()" << endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
STDataType* _a;
int _capacity;
int _top;
};
// 两个Stack实现队列
class MyQueue
{
public:
//编译器默认⽣成MyQueue的构造函数调⽤了Stack的构造，完成了两个成员的初始化
private:
Stack pushst;
Stack popst;
};
void test1()
{
MyQueue q1;
}
从test1函数的运行结果可以得知为了实现队列中的两个栈已经被析构函数释放了。而队列的析构函数调用的是编译器的默认析构函数，而这个默认析构函数则就是栈的析构函数。
注意：可以认为析构函数就是为了释放动态申请的空间，而销毁的时间则是在对象销毁时动态申请的空间自动调用析构函数进行销毁。
4.拷贝构造函数
下图是对拷贝构造函数为什么不能传值而是要传引用的原因（传值传参和传值返回都要调用拷贝构造函数）：
//拷贝构造函数
Stack(const Stack& st)
{
// 需要对_a指向资源创建同样⼤的资源再拷⻉值
_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
memcpy(_a, st._a, sizeof(STDataType) * st._top);
_top = st._top;
_capacity = st._capacity;
}//运用拷贝构造
Stack st2 = st1;
//or Stack st2(st1);#include<iostream>
#include<stdlib.h>
using namespace std;
typedef int STDataType;
class Stack
{
public:
Stack(int n = 4)
{
_a = (STDataType*)malloc(sizeof(STDataType) * n);
_capacity = n;
_top = 0;
}
//拷贝构造函数
Stack(const Stack& st)
{
// 需要对_a指向资源创建同样⼤的资源再拷⻉值
_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
memcpy(_a, st._a, sizeof(STDataType) * st._top);
_top = st._top;
_capacity = st._capacity;
}
void Push(STDataType x)
{
if (_top == _capacity)
{
int newcapacity = _capacity * 2;
STDataType* tmp = (STDataType*)realloc(_a, newcapacity *sizeof(STDataType));
_a = tmp;
_capacity = newcapacity;
}
_a[_top++] = x;
}
~Stack()
{
cout << "~Stack()" << endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
STDataType* _a;
int _capacity;
int _top;
};
// 两个Stack实现队列
class MyQueue
{
public:
private:
Stack pushst;
Stack popst;
};
int main()
{
Stack st1;
st1.Push(1);
st1.Push(2);
// Stack不显⽰实现拷⻉构造，⽤⾃动⽣成的拷⻉构造完成浅拷⻉
// 会导致st1和st2⾥⾯的_a指针指向同⼀块资源，析构时会析构两次，程序崩溃
Stack st2 = st1;
MyQueue mq1;
// MyQueue⾃动⽣成的拷⻉构造，会⾃动调⽤Stack拷⻉构造完成pushst/popst
// 的拷⻉，只要Stack拷⻉构造⾃⼰实现了深拷⻉，他就没问题
MyQueue mq2 = mq1;
return 0;
}5.运算符重载
1.概念
//类里定义的两个函数
Date& operator++()
{
cout << "前置++" << endl;
//...
return *this;
}
Date operator++(int)
{
Date tmp;
cout << "后置++" << endl;
//...
return tmp;
}2.赋值运算符重载
Stack& operator=(Stack& st)
{
_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
memcpy(_a, st._a, sizeof(STDataType) * st._top);
_top = st._top;
_capacity = st._capacity;
return (*this);
}//赋值运算符重载
d1=d3;
//拷贝构造
Date d1=d2;
Date d1(d2);6.const成员函数
void Print() const
{
cout << _year << "/" << _month << "/" << _day << endl;
}
