当前位置：首页 > news >正文

c++ 类和对象 —— 中【复习笔记】

news 来源：原创 2025/8/12 5:20:47

1. 类的默认成员函数

如果一个类什么成员都没有，简称空类。但实际上，任何类在不写成员时，编译器会自动生成6个默认成员函数（用户未显式实现，编译器生成的成员函数）

这6个成员函数可分为三类：

1. 初始化和清理：构造函数完成初始化工作；析构函数完成清理工作

2. 拷贝复制：拷贝构造是用同类对象初始化创建对象；赋值重载是把一个对象赋值给另一个对象

3. 取地址重载：普通对象和const对象取地址，这两个很少自己实现

2. 构造函数

2.1 引入

class Date
{
public:void Init(int year, int month, int day){_year = year;_month = month;_day = day;}private:int _year;int _month;int _day;
};

对于上面的Date类，如果每次创建对象后要设置信息都要调用 Init 的公有方法，会有些麻烦。那能不能在创建对象时就能设置信息呢？构造函数便出现了

构造函数是一个特殊的成员函数，创建类类型对象时由编译器自动调用，在对象整个生命周期内只调用一次

2.2 简介

构造函数虽然叫构造，但它的作用不是开空间创建对象，而是初始化对象

它具有以下特性：

1. 函数名和类名相同

2. 无返回值

3. 构造函数可以重载

4. 对象实例化时编译器自动调用

5. 如果类没有显式定义构造函数，那编译器会自动生成一个无参的默认构造函数；如果类显式定义了，那编译器不再生成

6. 构造函数对于类中内置类型成员不初始化，对于自定义类型成员调用它的默认成员函数（c++11中对于这一点打了补丁：内置类型成员在类中声明时可以给默认值）

7. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只有一个（即：无参构造函数、全缺省构造函数、编译器自己默认生成的构造函数都是默认构造函数，但为了避免二义性，通常只定义一种）


class Time
{
public:Time(){cout << "Time()" << endl;_hour = 0;_minute = 0;_second = 0;}private:int _hour;int _minute;int _second;
};class Date
{
public:/*//一旦显式定义任何构造函数，编译器将不再生成Date(int year, int month, int day){_year = year;_month = month;_day = day;}*///无参构造函数//如果使用无参构造函数创建对象，对象后不加括号，否则就变成函数声明Date(){}//带参构造函数Date(int year, int month, int day){_year = year;_month = month;_day = day;}//全缺省构造函数//全缺省和无参可以看为函数重载，但在调用时会出现二义性Date(int year = 2025, int month = 1, int day = 1){_year = year;_month = month;_day = day;}private://内置类型,c++11内置成员变量可以在声明时给默认值int _year;int _month;int _day;//自定义类型Time t;
};int main()
{Date d1;//调用无参构造函数Date d2(2025, 1, 1);//带参构造函数return 0;
}

3. 析构函数

3.1 引入

构造函数是完成初始化对象的工作的，和构造函数相反，析构函数就是完成对象中资源的清理工作（析构函数不完成对对象本身销毁），对象销毁时编译器自动调用

3.2 简介

析构函数具有以下特征：

1. 析构函数名是类名前加字符 ~

2. 无参数无返回类型

3. 一个类只能有一个析构函数，不能重载。如果没显式定义，系统自动生成默认析构函数

4. 对象生命周期结束，编译器自动调用析构函数

5. 对于对象中内置类型，编译器不需要资源清理，最后系统直接将其内存回收即可；对于自定义类型，会调用它的析构函数

6. 如果类没有申请资源，析构函数可以不写，使用生成的默认析构函数即可；但有资源申请时，一定要写，否则会资源泄露

class Time
{
public:~Time(){cout << "~Time()" << endl;}
private:int _hour;int _minute;int _second;
};class Date
{
private://内置类型int _year = 2025;int _month = 1;int _day = 1;//自定义类型Time t;//创建Date对象，销毁时要将Time类对象t销毁，编译器会给Date类生成一个默认析构函数//目的是调用Time类析构函数，确保Date对象销毁时内部每个自定义对象都可以销毁
};

4. 拷贝构造函数

4.1 引入

如果我们要创建一个和已经存在对象一样的新对象，那拷贝构造函数便发挥作用

拷贝构造函数目的是用已经存在的类类型对象创建新对象，编译器自动调用。所以它只有一个形参（对该类类型对象的引用，一般用const修饰）

4.2 简介

它的特征如下：

1. 拷贝构造函数是构造函数的一个重载形式

2. 参数只有一个且必须是该类类型对象的引用（用传值方式直接报错 --- 会引发无穷递归）

3. 如果没有显式定义，编译器自动生成默认拷贝构造函数。（默认拷贝构造函数按内存存储字节序完成拷贝，这种拷贝叫浅拷贝或值拷贝）

4. 对于默认拷贝构造函数，内置类型是浅拷贝，而自定义类型是调用其拷贝构造函数完成拷贝

（调用拷贝构造要传参，传参就要拷贝构造，拷贝构造就要传参，传参就要........,这也是为什么如果参数不是传引用，就会引发无穷递归）

5. 如果类中没涉及资源申请，拷贝构造可写可不写；一旦涉及资源申请，拷贝构造一定要写，否则是浅拷贝。

（比如：我们创建了一个栈对象s1，在它的构造函数中申请10个元素的空间；然后对象s2使用s1拷贝构造，而类中没有显式定义拷贝构造函数，那编译器自动生成默认拷贝构造函数，而这个拷贝构造是值拷贝，就会导致s1和s2指向同一块空间。当销毁s1和s2时，这个空间会释放多次，导致程序崩溃）

6. 拷贝构造的调用场景：

使用已存在对象创建新对象

函数参数类型为类类型对象

函数返回类型为类类型对象

一般对象传参使用引用类型；返回时，如果场景允许引用（如非局部类对象.....)尽量使用引用


#include<iostream>
using namespace std;
class Date
{
public:Date(int year, int month, int day){cout << "Date(int,int,int):" << this << endl;}Date(const Date& d){cout << "Date(const Date& d):" << this << endl;}~Date(){cout << "~Date():" << this << endl;}
private:int _year;int _month;int _day;
};Date Test(Date d)
{//调用拷贝构造函数创建tempDate temp(d);//以值方式返回，调用拷贝构造构造临时变量return temp;
}int main()
{//构造函数创建d1Date d1(2025, 1, 1);//传值方式传递，调用拷贝构造函数Test(d1);return 0;
}

5. 运算符重载

5.1 运算符重载

运算符重载是具有特殊函数名的函数，有函数名字、参数列表和返回值类型，返回值类型和参数列表和普通函数相似

函数名字：operator+要重载运算符符合（比如：operator< )

函数原型：返回值类型 operator操作符（参数列表）

注意事项：

1. 不能连接其他符号创建新操作符：operator@（这是错误的）

2. 重载操作符必须有一个类类型参数（即必须有一个自定义类型），操作符有几个操作数，重载函数就有几个参数

3. 用于内置类型的运算符，含义不能变

4. 作为类成员函数重载，形参看起来比操作数少1（成员函数第一个参数为隐藏的this)

5. 以下5个运算符不能重载：.* :: sizeof ? : .

class Date
{
public:Date(int year, int month, int day){_year = year;_month = month;_day = day;}//左操作数为this指针
bool operator==(const Date& d2)
{return _year == d2._year&& _month == d2._month&& _day == d2._day;
}private:int _year;int _month;int _day;
};//全局operator==
//如果成员变量是私有的，那无法访问；重载成成员函数即可
/*bool operator==(const Date& d1, const Date& d2)
{return d1._year == d2._year&& d1._month == d2._month&& d1._day == d2._day;
}*/void Test()
{Date d1(2025, 1, 1);Date d2(2025, 2, 2);
}

5.2 赋值运算符重载

1. 格式：

参数类型：const T&，传引用提高效率

返回值类型：T& ，返回引用提高效率，便于支持连续赋值

检测是否给自己赋值

返回*this：符合连续赋值含义

2.特征：

1. 赋值运算符只能重载成类的成员函数，不能重载成全局函数

（如果赋值运算符不显示实现，编译器默认生成。那再在类外自己实现一个全局赋值运算符重载，会导致冲突）

2. 用户没显式实现，编译器自动生成一个默认赋值运算符重载（值拷贝的方式）

（内置类型成员变量直接复制，自定义类型要调用对应类的复制运算符重载）

3. 如果类为涉及资源管理，赋值运算符可写可不写；但涉及资源管理必须自己实现

（比如：我们创建了一个栈对象s1，在它的构造函数中申请10个元素的空间；然后对象s2的构造函数也申请10个元素的空间，s2=s1，编译器会将s1的内容原封不动拷贝给s2，这导致s2的原空间丢失，内存泄漏；s1和s2共享一块空间，后续会导致一份空间释放两次）

class Time
{
public:Time(){_hour = 1;_minute = 1;_second = 1;}Time& operator=(const Time& t){if (this != &t){_hour = t._hour;_minute = t._minute;_second = t._second;}return *this;}
private:int _hour;int _minute;int _second;
};class Date
{
public:Date(int year = 2025, int month = 1, int day = 1){_year = year;_month = month;_day = day;}Date(const Date& d){_year = d._year;_month = d._month;_day = d._day;}//赋值重载Date& operator=(const Date& d){if (this != &d){_year = d._year;_month = d._month;_day = d._day;}return *this;}
private://内置类型int _year;int _month;int _day;//自定义类型Time t;
};

5.3 前置++和后置++重载

class Date
{
public:Date(int year = 2025, int month = 1, int day = 1){_year = year;_month = month;_day = day;}//前置++//this指向对象在函数结束后不销毁，用传引用Date& operator++(){_day += 1;return *this;}//后置++//为了让前置++和后置++区别，c++规定：后置++重载时多加一个int类型参数//但调用函数时这个参数不用传递，编译器自动传递//tmp为临时对象，只能传值返回Date operator++(int){Date tmp(*this);_day += 1;return tmp;}private:int _year;int _month;int _day;
};

6. const成员

const修饰的“成员函数”称为const成员函数，实际修饰该成员函数隐藏this指针，表示该成员函数中不能对类的任何成员进行修饰

class Date{public:Date(int year = 2025, int month = 1, int day = 1){_year = year;_month = month;_day = day;}//实际看为void print(const Date*this)void print()const{cout << "Print()const" << endl;cout << _year << endl;cout << _month << endl;cout << _day << endl;}private:int _year;int _month;int _day;};