C++类和对象-类的默认成员函数之拷贝构造函数与赋值运算符重载函数
前言：
当一个类中什么都没有时将此类称为空类，而空类中并非是什么也没有，编译器会自动生成六个默认的成员函数。
环境：vs2019
目录
拷贝构造函数
赋值运算符重载函数
一、拷贝构造函数
1 概念
拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。
2 特性
拷贝构造函数也是特殊的成员函数。
2.1 拷贝构造函数是构造函数的一个重载形式。
2.2 拷贝构造函数的参数有且只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。
2.3 当用户未显式定义拷贝构造函数时，编译器会生成一份默认的拷贝构造函数。此默认的拷贝构造函数对象按内存存储字节序完成拷贝，而此拷贝为浅拷贝（值拷贝）。实际上，编译器会根据实际情况来决定是否要生成一份默认的拷贝构造函数，当没必要生成时并不会生成，但是会完成拷贝的工作。
例1：
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "/" << _month << "/" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
void Testfunc1()
{
Date d1(2023, 8, 13);
//使用d1对象拷贝构造d2对象
Date d2(d1);
}
对象构造成功，编译器完成拷贝的工作。
类中并未实现对应的拷贝构造函数，那编译器有自动生成一份默认的吗？转到反汇编查看一下。
实际上，编译器并未生成默认的拷贝构造函数，而反汇编中实际上是完成值拷贝的工作。拷贝是逐字节拷贝，即将d1中的内容原封不动地拷贝到d2中。
在编译器生成的默认构造函数中，内置类型是按照字节方式直接拷贝，自定义类型是调用其拷贝构造函数来完成拷贝。如下例2。
例2：
class Time
{
public:
Time()
{
_hour = 1;
_minute = 1;
_second = 1;
}
Time(const Time& t)
{
_hour = t._hour;
_minute = t._minute;
_second = t._second;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
private:
int _year = 1900;
int _month = 1;
int _day = 1;
Time _t;
};
void Testfunc2()
{
Date d1;
Date d2(d1);
}
反汇编看到：编译器会生成默认的拷贝构造函数。
在生成的拷贝构造函数中，Date类中有自定义对象Time _t，所以会调用Time的拷贝构造函数来拷贝构造 _t 对象，此种情况下编译器一定会生成一份默认的拷贝构造函数。
思考🤔：编译器生成的默认的拷贝构造函数已经可以完成字节序的拷贝，这样的话，还需要用户自己显式实现一份吗？像Date日期类这样的类是没有必要的，那其他类又如何呢？
2.4 当类中涉及到资源的管理时，用户就得自己显式实现一份拷贝构造函数，否则就是浅拷贝，会造成内存泄漏。
typedef int DataType;
class Stack
{
public:
Stack(size_t capacity = 10)
{
_array = (DataType*)malloc(sizeof(DataType) * capacity);
if (_array == nullptr)
{
perror("malloc申请空间失败");
return;
}
_size = 0;
_capacity = capacity;
}
void Push(const DataType& data)
{
_array[_size] = data;
_size++;
}
~Stack()
{
if (_array)
{
free(_array);
_array = nullptr;
_size = 0;
_capacity = 0;
}
}
private:
DataType* _array;
size_t _size;
size_t _capacity;
};
void Testfunc3()
{
Stack s1;
s1.Push(1);
s1.Push(2);
s1.Push(3);
s1.Push(4);
//用s1拷贝构造一份s2
Stack s2(s1);
}
运行时，程序崩溃，两个对象的地址是一样的，当释放空间的时候，同一块空间会被多次释放，造成内存泄漏。
综上：当类中未涉及到资源的管理时，拷贝构造函数用户可以不显式实现；但当类中涉及到资源的管理时，则拷贝构造函数一定得显式实现。
2.5 拷贝构造函数调用场景
- 使用已存在对象创建新对象
- 函数参数类型为类类型对象
- 函数返回值类型为类类型对象
class Date
{
public:
Date(int year, int month, int day)
{
cout << "Date(int,int,int)" << endl;
}
Date(const Date& data)
{
cout << "Date(const Date& data)" << endl;
}
~Date()
{
cout << "~Date()" << this << endl;
}
private:
int _year;
int _month;
int _day;
};
Date Test(Date d)
{
Date temp(d);
return temp;
}
void Testfunc4()
{
Date d1(2023, 8, 13);
Test(d1);
}
二、赋值运算符重载函数
1 运算符重载
C++中为了增加代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，具有其返回值类型，函数名字及参数列表，其返回值类型与参数列表与其它函数并无不同。
- 不能通过连接其他特殊符号来创建新的操作符，如：operator@。
- 重载操作符必须有一个类类型参数
- 用于内置类型的运算符，其含义不能改变，如：内置的整形+，不能改变其原本的含义。
- 用于类成员函数重载时，其形参看起来比操作数目少1，而实际上成员函数的第一个参数为隐藏的this。
.*、::、sizeof、?:、.，这五个运算符不可重载。
① 将等号运算符重载函数重载成全局函数。
//全局的operator==
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
//类成员变量必须公有化
int _year;
int _month;
int _day;
};
bool operator==(const Date& d1, const Date& d2)
{
return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
}
② 将等号运算符重载函数重载为类的成员函数。
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
// 这里需要注意的是，左操作数是this，指向调用函数的对象
// 即：bool operator==(Date* this, const Date& d)
bool operator==(const Date& d)
{
return _year == d._year && _month == d._month && _day == d._day;
}
private:
int _year;
int _month;
int _day;
};
2 赋值运算符重载
2.1 赋值运算符重载格式
class Date
{
public:
//构造函数
Date(int year = 1900, 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;
}
void Print()
{
cout << _year << "/" << _month << "/" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
2.2 赋值运算符只能重载成类的成员函数，不能重载成全局函数。
赋值运算符若不显式实现，编译器会生成一个默认的，若用户再在类外自己实现一个全局的赋值运算符重载函数，两者就冲突了，所以赋值运算符重载函数只能是类的成员函数。
2.3 当用户未显式定义赋值运算符重载函数时，编译器会生成一份默认的赋值运算符重载函数。此默认的赋值运算符重载函数对象按内存存储字节序完成拷贝，而此拷贝为浅拷贝（值拷贝）。实际上，编译器会根据实际情况来决定是否要生成一份默认的赋值运算符重载函数，当没必要生成时并不会生成，但是会完成拷贝的工作。
其中，内置类型成员变量是直接赋值，而自定义类型成员变量需要调用对应类的赋值运算符重载函数完成赋值。
例1：
class Date
{
public:
//构造函数
Date(int year = 1900, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
完成了拷贝工作，但是编译器并未生成默认的赋值运算符重载函数。
例2：
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:
void Print()
{
cout << _year << "/" << _month << "/" << _day << endl;
}
private:
// 基本类型(内置类型)
int _year = 1900;
int _month = 1;
int _day = 1;
// 自定义类型
Time _t;
};
编译器生成了一份默认的赋值运算符重载函数。
2.4 当类中涉及到资源的管理时，用户就得自己显式实现一份赋值运算符重载函数，否则就是浅拷贝，造成内存泄漏。
如Stack类，编译器默认生成的赋值运算符重载函数是浅拷贝，涉及到资源的管理时就不可以。
typedef int DataType;
class Stack
{
public:
Stack(size_t capacity = 10)
{
_array = (DataType*)malloc(sizeof(DataType) * capacity);
if (_array == nullptr)
{
perror("malloc申请空间失败");
return;
}
_size = 0;
_capacity = capacity;
}
void Push(const DataType& data)
{
_array[_size] = data;
_size++;
}
~Stack()
{
if (_array)
{
free(_array);
_array = nullptr;
_size = 0;
_capacity = 0;
}
}
private:
DataType* _array;
size_t _size;
size_t _capacity;
};
void Testfunc3()
{
Stack s1;
s1.Push(1);
s1.Push(2);
s1.Push(3);
s1.Push(4);
//用s1赋值给s2
Stack s2;
s2 = s1;
}
当类中未涉及到资源管理，赋值运算符重载函数是否实现都可以；一旦涉及到资源管理就必须要实现，否则编译器以浅拷贝方式默认生成的赋值运算符重载函数会造成内存泄漏的问题。
3 前置++和后置++
前置++和后置++都是一元运算符，为了让前置++和后置++都形成正确的重载，C++规定，后置++重载时多增加一个int类型的参数，但调用函数时该参数不需要传递，编译器会自动传递。
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
//前置++：返回+1之后的结果
//this指针指向的对象函数结束之后并不会销毁，用引用方式进行返回结果提高效率
Date& operator++()
{
_day += 1;
return *this;
}
//后置++：先使用再进行++操作
// C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递
// 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this + 1
// 而temp是临时对象，因此只能以值的方式返回，不能返回引用
Date operator++(int)
{
Date temp(*this);
_day += 1;
return temp;
}
void Print()
{
cout << _year << "/" << _month << "/" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
4 const成员
将const修饰的成员函数称为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。
class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << "Print()" << endl;
cout << "year:" << _year << endl;
cout << "month:" << _month << endl;
cout << "day:" << _day << endl ;
}
void Print() const
{
cout << "Print()const" << endl;
cout << "year:" << _year << endl;
cout << "month:" << _month << endl;
cout << "day:" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
类中的成员函数都有隐藏的this指针，其类型为T* const，即this的指向不能修改，this指向空间中内容可以进行修改。
const成员函数，不可修改类成员变量，const修饰成员函数，实际上是在修饰this指针，则this指针类型为const T* const，即this指针的指向和指向空间内容都不可以修改。
若成员函数内部一定不会修改成员变量，则最好将成员函数设置为const成员函数。
问题：
- const对象可以调用非const成员函数吗？
- 非const对象可以调用const成员函数吗？
- const 成员函数内可以调用其它非const成员函数吗？
- 非const成员函数内可以调用其它的const成员函数吗？
问题1：const对象可以调用非const成员函数吗？
const对象不可以调用普通成员函数。
问题2：非const对象可以调用const成员函数吗？
普通对象可以调用const成员函数。
问题3：const 成员函数内可以调用其它非const成员函数吗？
const 成员函数内不可以调用其它非const成员函数，只能调用const成员函数。
class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
//非const成员函数
void fun1(){}
//const成员函数
void fun2()const {}
//非const成员函数
void Show()
{
fun1();
fun2();
cout << _year << "/" << _month << "/" << _day;
}
//const成员函数
void Print() const
{
//fun1(); // 编译失败：const成员函数内不可以调用普通成员函数
fun2();
cout << _year << "/" << _month << "/" << _day;
}
private:
int _year;
int _month;
int _day;
};
问题4：非const成员函数内可以调用其它的const成员函数吗？
非const 成员函数可以调用其它const成员函数。
接上节：C++类和对象-类的默认成员函数之构造函数与析构函数
此节完！！！
217
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
