我们先来定义一个日期的类Date
:
#include
using namespace std;
class Date
{
public:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year; // 年
int _month; // 月
int _day; // 日
};
int main()
{
Date d1, d2;
d1.Init(2022, 1, 11);
d2.Init(2022, 1, 12);
d1.Print();
d2.Print();
return 0;
}
对于上面一个类,有这样一个问题:
Date
类中有Init
与Print
两个成员函数,函数体中并没有关于不同对象的区分,那么当d1
调用Init
函数时,该函数是如何知道应该设置d1
对象,而不是设置d2
对象的呢?
C++通过引入this
指针来解决这个问题。实际上,C++编译器给每个非静态的成员函数增加了一个隐藏的指针参数,让该指针指向当前对象(函数运行时调用该函数的对象),在函数体中所有“成员变量” 的操作,都是通过该指针去访问,只不过所有的操作对用户是透明的,即用户不需要来传递,编译器自动完成。
this
指针的类型:类的类型 const*,所以成员函数中,不能给this
指针赋值。this
指针只能在成员函数的内部使用。this
指针本质上是成员函数的形参,所以this
指针是存储在栈中的。当对象调用成员函数时,函数将对象地址作为实参传递给this
形参。所以对象中不存储this
指针。this
指针是成员函数第一个隐含的指针形参,一般情况下由编译器通过ecx
寄存器自动传递,不需要用户传递。this
指针例1:下面程序编译运行的结果是什么?
#include
using namespace std;
class A
{
public:
void Print()
{
cout << "Print()" << endl;
}
private:
int _a;
};
void test1()
{
A* p = nullptr;//空指针
p->Print();
}
void test2()
{
A* p = nullptr;//空指针
(*p).Print();
}
int main()
{
test1();
test2();
return 0;
}
输出结果:
从输出结果可以看到,程序正常运行了,这是为什么呢?
这是因为成员函数Print
实际上在公共的代码段而并不在对象里面,所以虽然p
是一个空指针,但p->Print()
在这里并不代表解引用,而是直接去公共区域调用了函数Print
,(*p).Print()
也同理。
如果是这样的话,那能不能不用对象直接调用Print
函数呢?
#include
using namespace std;
class A
{
public:
void Print()
{
cout << "Print()" << endl;
}
private:
int _a;
};
int main()
{
Print();
return 0;
}
运行结果:
可以看到,编译器报错了。这是因为Print
会受到类域的限制,如果不用对象直接调用Print
函数那么编译器将无法找到Print
函数。
例2:下面程序编译运行的结果是什么?
#include
using namespace std;
class A
{
public:
void PrintA()
{
cout << _a << endl;
}
private:
int _a;
};
int main()
{
A* p = nullptr;
p->PrintA();
return 0;
}
输出结果:
从输出结果可以看到,程序崩溃了。这是因为PrintA
函数体内部的cout << _a << endl
语句等价于cout << this->_a << endl
而此时PrintA
函数的参数为空指针,那么对空指针进行解引用自然就会发生崩溃了。
#include
#include
#include
typedef int DataType;
typedef struct Stack
{
DataType* array;
int capacity;
int size;
}Stack;
void StackInit(Stack* ps)
{
assert(ps);
ps->array = (DataType*)malloc(sizeof(DataType) * 3);
if (NULL == ps->array)
{
assert(0);
return;
}
ps->capacity = 3;
ps->size = 0;
}
void StackDestroy(Stack* ps)
{
assert(ps);
if (ps->array)
{
free(ps->array);
ps->array = NULL;
ps->capacity = 0;
ps->size = 0;
}
}
void CheckCapacity(Stack* ps)
{
if (ps->size == ps->capacity)
{
int newcapacity = ps->capacity * 2;
DataType* temp = (DataType*)realloc(ps->array,
newcapacity * sizeof(DataType));
if (temp == NULL)
{
perror("realloc申请空间失败!!!");
return;
}
ps->array = temp;
ps->capacity = newcapacity;
}
}
void StackPush(Stack* ps, DataType data)
{
assert(ps);
CheckCapacity(ps);
ps->array[ps->size] = data;
ps->size++;
}
int StackEmpty(Stack* ps)
{
assert(ps);
return 0 == ps->size;
}
void StackPop(Stack* ps)
{
if (StackEmpty(ps))
return;
ps->size--;
}
DataType StackTop(Stack* ps)
{
assert(!StackEmpty(ps));
return ps->array[ps->size - 1];
}
int StackSize(Stack* ps)
{
assert(ps);
return ps->size;
}
int main()
{
Stack s;
StackInit(&s);
StackPush(&s, 1);
StackPush(&s, 2);
StackPush(&s, 3);
StackPush(&s, 4);
printf("%d\n", StackTop(&s));
printf("%d\n", StackSize(&s));
StackPop(&s);
StackPop(&s);
printf("%d\n", StackTop(&s));
printf("%d\n", StackSize(&s));
StackDestroy(&s);
return 0;
}
可以看到,在用C语言实现Stack
时,Stack
相关操作函数有以下共性:
Stack*
。NULL
。Stack*
参数操作栈的.Stack
结构体变量的地址。结论:C语言中结构体只能定义存放数据的结构,而操作数据的方法不能放在结构体中,即数据和操作数据的方式是分离开的,而且实现上相对复杂,涉及到大量指针操作,稍不注意可能就会出错。
#include
#include
using namespace std;
typedef int DataType;
class Stack
{
public:
void Init()
{
_array = (DataType*)malloc(sizeof(DataType) * 3);
if (NULL == _array)
{
perror("malloc申请空间失败!!!");
return;
}
_capacity = 3;
_size = 0;
}
void Push(DataType data)
{
CheckCapacity();
_array[_size] = data;
_size++;
}
void Pop()
{
if (Empty())
return;
_size--;
}
DataType Top() { return _array[_size - 1]; }
int Empty() { return 0 == _size; }
int Size() { return _size; }
void Destroy()
{
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
}
}
private:
void CheckCapacity()
{
if (_size == _capacity)
{
int newcapacity = _capacity * 2;
DataType* temp = (DataType*)realloc(_array, newcapacity *
sizeof(DataType));
if (temp == NULL)
{
perror("realloc申请空间失败!!!");
return;
}
_array = temp;
_capacity = newcapacity;
}
}
private:
DataType* _array;
int _capacity;
int _size;
};
int main()
{
Stack s;
s.Init();
s.Push(1);
s.Push(2);
s.Push(3);
s.Push(4);
printf("%d\n", s.Top());
printf("%d\n", s.Size());
s.Pop();
s.Pop();
printf("%d\n", s.Top());
printf("%d\n", s.Size());
s.Destroy();
return 0;
}
在C++中,通过类可以将数据以及操作数据的方法进行完美结合,通过访问权限可以控制哪些方法在类外可以被调用,即封装。在使用时就像使用自己的成员一样,更符合人对一件事物的认知。 而且和C语言相比,每个方法不需要传递Stack*
的参数,编译器在编译之后会将该参数自动还原,即C++中Stack*
参数是编译器维护的,C语言中需要用户自己维护。
之前我们说过,如果一个类中什么成员都没有,简称为空类。任何类在什么都不写时,编译器会自动生成以下6个默认成员函数。 默认成员函数指的就是用户没有显式实现,但是编译器会生成的成员函数。
我们以下面一个描述日期的类Date
为例:
#include
using namespace std;
class Date
{
public:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
d1.Init(2022, 7, 5);
d1.Print();
Date d2;
d2.Init(2022, 7, 6);
d2.Print();
return 0;
}
对于Date
类,可以通过公有方法Init
给对象设置日期,但如果每次创建对象时都调用该方法设置信息,还是有点麻烦。那能否在对象创建时,就将信息设置进去呢? C++中,引入了构造函数来解决这个问题。
构造函数是一个特殊的成员函数,名字与类名相同,创建类类型对象时由编译器自动调用,以保证每个数据成员都有一个合适的初始值,并且在对象整个生命周期内只调用一次。
需要注意的是,构造函数虽然名称叫构造,但是构造函数的主要任务并不是开辟空间创建对象,而是初始化对象。
例:
#include
using namespace std;
class Date
{
public:
// 1.无参构造函数
Date()
{}
// 2.带参构造函数
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1; // 调用无参构造函数
Date d2(2015, 1, 1); // 调用带参的构造函数
Date d3();
d1.Print();
d2.Print();
// 注意:如果通过无参构造函数创建对象时,对象后面不用跟括号,否则就成了函数声明
// 以下代码的函数:声明了d3函数,该函数无参,返回一个日期类型的对象
//d3.Print(); // warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
return 0;
}
输出结果:
例:
#include
using namespace std;
class Date
{
public:
// 如果用户显式定义了构造函数,编译器将不再生成
/* Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}*/
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
// 将Date类中构造函数屏蔽后,代码可以通过编译,因为编译器生成了一个无参的默认构造函数
// 将Date类中构造函数放开,代码编译失败,因为一旦显式定义任何构造函数,编译器将不再生成
// 无参构造函数,放开后报错:error C2512: “Date”: 没有合适的默认构造函数可用
Date d1;
d1.Print();
return 0;
}
放开前运行结果:
放开后运行结果:
int/char
等)和自定义类型(如使用class/struct/union
等自己定义的类型),而C++的语法又规定编译器生成的默认构造函数不会对内置类型进行处理,也就是说对于内置类型的成员,虽然调用了默认构造函数但是依旧是随机值,而对于自定义类型的成员则会去调用它的默认构造函数。注意:不传参数就可以调用的构造函数就叫默认构造函数,一般建议每个类都提供一个默认构造函数。
例:
#include
using namespace std;
class Time
{
public:
Time()
{
cout << "Time()" << endl;
_hour = 0;
_minute = 0;
_second = 0;
}
void Print()
{
cout << _hour << "时" << _minute << "分" << _second << "秒" << endl;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
public:
void Print()
{
cout << _year << "年" << _month << "月" << _day << "日";
this->_t.Print();
}
/*Date()
{
cout << "Date()" << endl;
}*/
private:
//基本类型
int _year;
int _month;
int _day;
//自定义类型
Time _t;
};
int main()
{
Date d;
d.Print();
return 0;
}
输出结果:
从输出结果可以看到,编译器生成默认的构造函数会对自定类型成员_t
调用的它的默认成员函数。
注意:C++11中针对内置类型成员不初始化的缺陷打了补丁,打了补丁后内置类型成员变量在类中声明时可以给默认值。
例:
#define _CRT_SECURE_NO_WARNINGS 1
//构造函数缺陷
#include
using namespace std;
class Time
{
public:
Time()
{
cout << "Time()" << endl;
_hour = 0;
_minute = 0;
_second = 0;
}
void Print()
{
cout << _hour << "时" << _minute << "分" << _second << "秒" << endl;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
public:
void Print()
{
cout << _year << "年" << _month << "月" << _day << "日";
this->_t.Print();
}
/*Date()
{
cout << "Date()" << endl;
}*/
private:
//基本类型型(内置类型)
int _year = 2023;
int _month = 10;
int _day = 3;
//自定义类型
Time _t;
};
int main()
{
Date d;
d.Print();
return 0;
}
输出结果:
例:
#include
using namespace std;
class Date
{
public:
//无参的构造函数
Date()
{
_year = 1900;
_month = 1;
_day = 1;
}
//全缺省的构造函数
Date(int year = 1900, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
void Test()
{
Date d1;
}
int main()
{
Test();
return 0;
}
运行结果:
通过前面构造函数的学习,我们知道一个对象是怎么来的,那一个对象又是怎么没的呢?
与构造函数功能相反,析构函数不是完成对对象本身的销毁,局部对象销毁工作是由编译器完成的,而对象在销毁时会自动调用析构函数,完成对象中资源的清理工作。
~
。例:
#include
using namespace std;
typedef int DataType;
class Stack
{
public:
Stack(size_t capacity = 3)
{
_array = (DataType*)malloc(sizeof(DataType) * capacity);
if (NULL == _array)
{
perror("malloc申请空间失败!!!");
return;
}
_capacity = capacity;
_size = 0;
}
void Push(DataType data)
{
// CheckCapacity();
_array[_size] = data;
_size++;
}
// 其他方法...
~Stack()
{
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
}
}
private:
DataType* _array;
int _capacity;
int _size;
};
void TestStack()
{
Stack s;
s.Push(1);
s.Push(2);
}
int main()
{
TestStack();
return 0;
}
Stack
类。例:
#include
using namespace std;
class Time
{
public:
~Time()
{
cout << "~Time()" << endl;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
private:
//基本类型型(内置类型)
int _year = 1970;
int _month = 1;
int _day = 1;
//自定义类型
Time _t;
};
int main()
{
Date d;
return 0;
}
输出结果:
从输出结果可以看到,在main
函数中根本没有直接创建Time
类的对象,但是最后还是调用了Time
类的析构函数,这就是因为main
函数中创建了Date
类对象d
,而d
中包含了4个成员变量,其中_year
、_month
, _day
三个是内置类型成员,销毁时不需要资源清理,而_t
是Time
类对象,所以在销毁d
时,要将其内部包含的Time
类的_t
对象销毁,所以要调用Time
类的析构函数。但是:main
函数中不能直接调用Time
类的析构函数,实际要释放的是Date
类对象,所以编译器会调用Date
类的析构函数,而Date
没有显式提供,所以编译器会给Date
类生成一个默认的析构函数,目的是在其内部调用Time
类的析构函数,也就是说当Date
的对象销毁时,要保证其内部每个自定义对象都能被正确销毁。
总结:创建哪个类的对象则调用该类的析构函数,销毁哪个类的对象则调用该类的析构函数。
在现实生活中,可能存在一个与你一样的自己,我们称其为双胞胎。
而在C++中,拷贝构造函数就可以实现创建一个与已存在对象一模一样的新对象。
const
修饰),而且在用已存在的类类型对象创建新对象时由编译器自动调用,如果使用传值方式进行传参那么编译器会直接报错,因为C++规定自定义类型的传值需要去调用拷贝构造函数,也就是在使用传值方式进行传参的过程中会调用拷贝构造函数,而由于这个拷贝构造函数是以传值方式实现的受C++语法的限制会又调用拷贝构造函数,层层调用最终导致无穷递归调用。例:
#include
using namespace std;
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;
// cout << "Date(const Date d)" << endl;
//}
Date(const Date& d) // 正确写法
{
_year = d._year;
_month = d._month;
_day = d._day;
cout << "Date(const Date& d)" << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
Date d2(d1);
return 0;
}
错误写法运行结果:
原因图解:
正确写法运行结果:
例:
#include
using namespace std;
class Time
{
public:
Time()
{
_hour = 1;
_minute = 1;
_second = 1;
}
Time(const Time& t)
{
_hour = t._hour;
_minute = t._minute;
_second = t._second;
cout << "Time::Time(const Time&)" << endl;
}
void Print()
{
cout << _hour << "时" << _minute << "分" << _second << "秒" << endl;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
public:
void Print()
{
cout << _year << "年" << _month << "月" << _day << "日";
this->_t.Print();
}
private:
//基本类型(内置类型)
int _year = 1970;
int _month = 1;
int _day = 1;
//自定义类型
Time _t;
};
int main()
{
Date d1;
// 用已经存在的d1拷贝构造d2,此处会调用Date类的拷贝构造函数
// 但Date类并没有显式定义拷贝构造函数,则编译器会给Date类生成一个默认的拷贝构造函数
Date d2(d1);
d2.Print();
return 0;
}
输出结果:
既然编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝,那么对于所有的类是不是都不需要自己来显式实现呢?我们可以通过下面的类来感受一下:
#include
using namespace std;
typedef int DataType;
class Stack
{
public:
Stack(size_t capacity = 10)
{
_array = (DataType*)malloc(capacity * sizeof(DataType));
if (nullptr == _array)
{
perror("malloc申请空间失败");
return;
}
_size = 0;
_capacity = capacity;
}
void Push(const DataType& data)
{
// CheckCapacity();
_array[_size] = data;
_size++;
}
~Stack()
{
if (_array)
{
free(_array);
_array = nullptr;
_capacity = 0;
_size = 0;
}
}
private:
DataType* _array;
size_t _size;
size_t _capacity;
};
int main()
{
Stack s1;
s1.Push(1);
s1.Push(2);
s1.Push(3);
s1.Push(4);
Stack s2(s1);
return 0;
}
运行结果:
可以看到,当我们以同样的方式对Stack
类的对象s2
进行拷贝构造时,程序崩溃了,这是什么原因呢?
我们可以通过上图帮助我们理解崩溃的原因。在main
函数中,s1
对象通过调用构造函数创建,而在构造函数中,默认申请了10个元素的空间,然后将1、2、3、4存了进去。
在后续构造s2
对象的过程中,由于s2
对象使用s1
拷贝构造,而Stack
类没有显式定义拷贝构造函数,所以编译器会给Stack
类生成一份默认的拷贝构造函数,而又因为默认拷贝构造函数是按照值进行拷贝的,也就是说默认拷贝构造函数会将s1
中的内容原封不动地拷贝到s2
中,所以s1
和s2
指向了同一块内存空间。
当程序退出时,s2
和s1
都要销毁。而根据析构“后进先出”(即后创建的先销毁)的原则,s2
将先被销毁,此时s2
销毁时调用析构函数已经将0x11223344
的空间释放了,但是s1
中仍然指向0x11223344
这块空间,到s1
销毁时,会将0x11223344
的空间再释放一次,一块内存空间多次释放,必然会造成程序崩溃。
结论:类中一旦涉及到资源申请时,一定要写拷贝构造函数,否则就是浅拷贝;而类中没有涉及资源申请时,写还是不写拷贝构造函数都可以。
例:
#include
using namespace std;
class Date
{
public:
Date(int year, int minute, 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)
{
Date temp(d);
return temp;
}
int main()
{
Date d1(2022, 1, 13);
Test(d1);
return 0;
}
输出结果:
程序解读:
总结:为了提高程序效率,一般对象传参时,尽量使用引用类型;返回时根据实际场景,能用引用尽量使用引用。
C++为了增强代码的可读性引入了运算符重载,让自定义类型对象也可以使用运算符。
运算符重载是具有特殊函数名的函数,也具有其返回值类型、函数名以及参数列表,其返回值类型与参数列表与普通的函数类似。
函数名为:operator + 需要重载的运算符符号
函数原型:返回值类型 + operator +(参数列表)
注意:
+
,不能改变其含义。1
,但是成员函数里还隐藏了一个this
参数。.*
、::
、sizeof
、 ?:
、.
这5个运算符不能重载,这个经常在笔试选择题中出现。例:用全局的operator==
实现判断Date
类相等:
//全局的operator==
#include
using namespace std;
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;
};
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(2023, 9, 27);
Date d2(2023, 9, 27);
Date d3(2023, 9, 27);
Date d4(2023, 9, 26);
cout << (d1 == d2) << endl;//d1 == d2会被转换成operator==(d1,d2)
cout << (d3 == d4) << endl;
}
int main()
{
Test();
return 0;
}
成员变量为公有时运行结果:
这里会发现运算符重载成全局的就需要成员变量是公有的,但如果这样的话封装性就无法得到保证了。这里其实可以用我们后面学习的友元解决,或者干脆重载为成员函数。
例:
//重载为成员函数
#include
using namespace std;
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
// bool operator==(Date* this, const Date& d2)
// 这里需要注意的是,成员函数都有一个默认的隐藏参数,即左操作数是this,指向调用函数的对象
bool operator==(const Date & d2)
{
return _year == d2._year
&& _month == d2._month
&& _day == d2._day;
}
private:
int _year;
int _month;
int _day;
};
void Test()
{
Date d1(2023, 9, 27);
Date d2(2023, 9, 27);
Date d3(2023, 9, 27);
Date d4(2023, 9, 26);
cout << (d1 == d2) << endl;
cout << (d3 == d4) << endl;
}
int main()
{
Test();
return 0;
}
运行结果:
刚才我们实现了判断Date
类相等的函数operator==
,那当我们还想实现诸如operator>
、operator<
、operator>=
这样逻辑相似的函数时,如果每一个函数都要单独写一段代码进行实现,那未免也太麻烦了,有没有什么简化的方法呢?
这里我们就可以通过对运算符重载的复用来实现,还是以Date
类为例,要实现所有的比较关系的话,我们实际上只需在实现operator==
的基础上,再实现一个operator<
或者operator>
即可:
bool operator==(const Date & d2)
{
return _year == d2._year
&& _month == d2._month
&& _day == d2._day;
}
bool operator<(const Date& d)
{
return _year < d._year
|| (_year == d._year && _month < d._month)
|| (_year == d._year && _month == d._month && _day < d._day);
}
bool operator<=(const Date& d)
{
return *this < d || *this == d;
}
bool operator>(const Date& d)
{
return !(*this <= d);
}
bool operator>=(const Date& d)
{
return !(*this < d);
}
bool operator!=(const Date& d)
{
return !(*this == d);
}
可以看到,上面的代码只具体实现了operator==
和operator<
,其他的关系直接通过这两个函数的复用就实现了,以operator>
为例,operator>
就是通过复用operator<=
,然后对它的判断结果进行取反来进行实现的。
实际上,上面这一套判断逻辑,对所有的类均适用。
以往赋值运算符=
只能在内置类型之间使用,而如果要让自定义类型也能通过=
进行赋值,就需要对赋值运算符进行重载。
有了刚才实现运算符重载的经验,那我们实现赋值运算符的重载实际上也没有什么难度。
例:
#include
using namespace std;
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
void operator=(const Date& d)//赋值运算符重载
{
_year = d._year;
_month = d._month;
_day = d._day;
}
void Print()
{
cout << _year << "年" << _month << "月" << _day << "日" << endl;
}
private:
int _year;
int _month;
int _day;
};
void Test()
{
Date d1(2023, 9, 27);
Date d2;
d1.Print();
d2.Print();
d2 = d1;
d1.Print();
d2.Print();
}
int main()
{
Test();
return 0;
}
运行结果:
可以看到,我们设计的赋值运算符重载实现了它的功能,但实际上当前设计的还是存在缺陷的,比较突出的一点就是它不支持连续赋值,因为它的返回类型是void
。
要实现连续赋值,那么它应该返回当前被赋值的对象,也就是返回左操作数的值。除此之外,我们还应该考虑到自己给自己赋值的情况,尤其在需要深拷贝时,会降低程序运行的效率,所以遇到这种情况时,我们直接返回即可。那么对于刚才的operator=
函数我们可以进行如下改造:
#include
using namespace std;
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
/* void operator=(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}*/
bool operator==(const Date& d2)
{
return _year == d2._year
&& _month == d2._month
&& _day == d2._day;
}
bool operator!=(const Date& d)
{
return !(*this == d);
}
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;
};
void Test()
{
Date d1(2023, 9, 27);
Date d2;
Date d3;
d1.Print();
d2.Print();
d3.Print();
d3 = d2 = d1;
d1.Print();
d2.Print();
d3.Print();
}
int main()
{
Test();
return 0;
}
输出结果:
可以看到,改造后的operator=
函数就支持连续赋值了。
需要注意的是,赋值运算符只能重载成类的成员函数而不能重载成全局函数,原因在于赋值运算符如果不显式实现,那么编译器就会生成一个默认的赋值运算符重载,此时如果用户再在类外自己实现一个全局的赋值运算符重载,那么就和编译器在类中生成的默认赋值运算符重载冲突了,所以赋值运算符重载只能是类的成员函数。
例:
#include
using namespace std;
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;
};
// 赋值运算符重载成全局函数,注意重载成全局函数时没有this指针了,需要给两个参数
Date& operator=(Date& left, const Date& right)
{
if (&left != &right)
{
left._year = right._year;
left._month = right._month;
left._day = right._day;
}
return left;
}
void Test()
{
Date d1(2023, 9, 27);
Date d2;
Date d3;
d3 = d2 = d1;
}
int main()
{
Test();
return 0;
}
运行结果:
这里还需要注意的是,由编译器生成的默认赋值运算符重载,是以值的方式逐字节拷贝,也就是说,对于内置类型成员变量是直接赋值的,但是对于自定义类型成员变量则需要调用对应类的赋值运算符重载才能完成赋值。
例:
#include
using namespace std;
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;
//}
void Print()
{
cout << _hour << "时" << _minute << "分" << _second << "秒" << endl;
}
private:
int _hour;
int _minute;
int _second;
};
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 << "日";
this->_t.Print();
}
private:
// 基本类型(内置类型)
int _year;
int _month;
int _day;
// 自定义类型
Time _t;
};
int main()
{
Date d1;
Date d2(2023, 10, 4);
d1.Print();
d2.Print();
d1 = d2;
d1.Print();
d2.Print();
return 0;
}
运行结果:
所以,虽然编译器生成的默认赋值运算符重载函数已经可以完成字节序的值拷贝了,但是对于一些涉及到资源管理的类,则必须要自己实现赋值运算符的重载,否则会出现无法预料的结果。
例:
#include
using namespace std;
typedef int DataType;
class Stack
{
public:
Stack(size_t capacity = 10)
{
_array = (DataType*)malloc(capacity * sizeof(DataType));
if (nullptr == _array)
{
perror("malloc申请空间失败");
return;
}
_size = 0;
_capacity = capacity;
}
void Push(const DataType& data)
{
// CheckCapacity();
_array[_size] = data;
_size++;
}
~Stack()
{
if (_array)
{
free(_array);
_array = nullptr;
_capacity = 0;
_size = 0;
}
}
private:
DataType* _array;
size_t _size;
size_t _capacity;
};
int main()
{
Stack s1;
s1.Push(1);
s1.Push(2);
s1.Push(3);
s1.Push(4);
Stack s2;
s2 = s1;
return 0;
}
运行结果:
可以看到,当我们以同样的方式对Stack
类的对象s2
进行拷贝构造时,程序崩溃了,原因就在于Stack
类中涉及到了资源管理,而Stack
的赋值运算符重载又是依靠编译器实现的。
图解:
结论:
*this
:要复合连续赋值的含义。我们通过下面这段代码来感受一下赋值运算符重载和拷贝构造的区别:
#include
using namespace std;
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
bool operator==(const Date& d2)
{
return _year == d2._year
&& _month == d2._month
&& _day == d2._day;
}
bool operator!=(const Date& d)
{
return !(*this == d);
}
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;
};
void Test()
{
Date d1(2023, 9, 27);
Date d2 = d1;//拷贝构造
d1.Print();
d2.Print();
Date d3;
d3 = d1;//赋值重载
cout << "--------------------------------" << endl;
d1.Print();
d2.Print();
d3.Print();
}
int main()
{
Test();
return 0;
}
运行结果:
由于赋值重载是在两个已经定义好的对象之间进行的,虽然Date d2 = d1;
这条语句中用了赋值重载运算符=
,但是这条语句的意思是用d1
来初始化d2
,也就是用一个已经定义好的对象来初始化一个正在定义的对象,所以Date d2 = d1;
这条语句实际上是拷贝构造,而d3 = d1;
这条语句才是赋值重载。
前置++
和后置++
的重载之所以要单独拎出来讲,是因为它们和运算符+
、-
相比,有需要注意的地方。
由于前置++
和后置++
都是一元运算符,为了让前置++
与后置++
能正确重载,C++规定:后置++
重载时多增加一个int
类型的参数,但调用函数时该参数不用传递,编译器自动传递。
例:
#include
using namespace std;
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;
}
//后置++:返回+1之前的结果
// 注意:后置++是先使用后+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;
};
int main()
{
Date d;
Date d1(2022, 1, 13);
d = d1++;
d.Print();
d1.Print();
cout << "-------------------------" << endl;
d = ++d1;
d.Print();
d1.Print();
return 0;
}
运行结果:
在引出const
函数之前,我们先来看下面这种情况:
#include
using namespace std;
class A
{
public:
void Print()
{
cout << _a << endl;
}
private:
int _a = 10;
};
int main()
{
A aa;
//const A aa;
aa.Print();
return 0;
}
const
修饰aa
前的运行结果:
const
修饰aa
后的运行结果:
可以看到,当对象aa
没有被const
修饰时,它能够顺利运行,但是当aa
被const
修饰后再运行编译器就报错了。
之所以会报错,是因为这里涉及到一个权限被放大的问题。
在这个例子中,当我们把aa
传进Print
函数时,本质上传的是aa
的地址,aa
在没有被const
修饰前,&aa
的类型为A*
,而Print
的隐藏参数this
的类型为A* const
,也就是说当把aa
传进Print
函数后this
的指向是不能被改变的,这是个权限缩小的过程,所以编译器允许;而当aa
被const
修饰后,&aa
的类型就成了const A*
,也就是说这个时候aa
是不能被修改的,但传进Print
函数后却反而可以被修改了,这个过程就把this
的权限放大了,而这是不被编译器所允许的。
又由于this
是隐藏的参数,我们没有办法进行修改,所以我们只能对函数用const
进行修饰,那么我们就将const
修饰的成员函数称为const
成员函数,这个const
实际修饰的是成员函数隐藏的this
指针,修饰后this
的类型就变成了const A*
。
虽然我们实际情况下很少在定义的时候用const
修饰变量,但是像下面的情况却并不少见:
#include
using namespace std;
class A
{
public:
void Print() const
{
cout << _a << endl;
}
private:
int _a = 10;
};
void Func(const A& x)
{
x.Print();
}
int main()
{
A aa;
Func(aa);
return 0;
}
const
修饰Print
函数前的运行结果:
const
修饰Print
函数后的运行结果:
可以看到,当我们把对象传给某个参数被const
修饰的函数,而这个函数的内部所调用的函数却没有被const
修饰时,就容易出错。
因此,只要函数内部不对成员变量进行改变一般都建议用const
修饰一下,加上之后const
对象和普通对象都可以调用。
对于这两个操作符一般不需要重载,使用编译器生成的默认取地址的重载即可。
例:
#include
using namespace std;
class A
{
public:
/*A* operator&()
{
cout << "My &:";
return this;
}
const A* operator&() const
{
cout << "My const&:";
return this;
}*/
private:
int _a = 10;
};
int main()
{
A aa;
const A bb;
cout << &aa << endl;
cout << &bb << endl;
return 0;
}
使用编译器默认生成的:
使用自己写的:
只有特殊情况,才需要重载,比如想让别人获取到指定的内容:
#include
using namespace std;
class A
{
public:
A* operator&()
{
return nullptr;//拒绝取地址
}
const A* operator&() const
{
return nullptr;//拒绝取地址
}
private:
int _a = 10;
};
int main()
{
A aa;
const A bb;
cout << &aa << endl;
cout << &bb << endl;
return 0;
}
运行结果: