文章目录
- 类的默认成员函数
- 构造函数
- 析构函数
- 拷贝构造函数
- 赋值运算符重载
- 运算符重载
- const成员函数
类的默认成员函数
在C++中,类(class)可以拥有多种成员函数,其中一些成员函数在类定义中没有显式声明时,编译器会隐式地为该类生成。这些由编译器自动生成的成员函数被称为默认成员函数(也称为特殊成员函数)。它们包括:
- 默认构造函数(Default Constructor)
- 析构函数(Destructor)
- 拷贝构造函数(Copy Constructor
- 拷贝赋值运算符(Copy Assignment Operator)
- 移动构造函数(Move Constructor) 和 移动赋值运算符(Move Assignment Operator),这是C+11以后引入的,比较复杂,这里就不介绍,重点将前4个。
构造函数
特征:
- 函数名和类名相同
- 无返回值
- 对象实例化时编译器自动调用对应的构造函数。
- 构造函数可以重载。
- 如果类中没有显式定义构造函数,则C++编译器会自动生成一个无参的默认构造函数,一旦
用户显式定义编译器将不再生成。
class Data
{
public:
//1.无参构造函数
/*Data()
{
int _year = 1;
int _month = 1;
int _day = 1;
}*/
//2.带参构造函数
//Date(int year, int month, int day)
//{
// _year = year;
// _month = month;
// _day = day;
//}
//3.全缺省构造函数
//Date(int year = 1, int month = 1, int day = 1)
//{
// _year = year;
// _month = month;
// _day = day;
//}
private:
int _year;
int _month;
int _day;
};
int main()
{
Data d1;
Data d2(2024,7,15);
Data d3(2024);
return 0;
}
前面我们说过:
“如果没有为类定义任何构造函数,编译器会生成一个默认构造函数。这个构造函数不接受任何参数,并且只进行成员变量的默认初始化(对于内置类型不做任何操作,对于类类型调用其默认构造函数)。如果类中定义了任何构造函数(包括带参数的构造函数),编译器就不会自动生成默认构造函数。”所以,无参构造函数和全缺省构造函数也是默认构造函数,因为这两种构造函数都可以不用传参。这三种默认构造只能存在一个,不能同时存在。
总结:不传实参就可以调用的构造就叫默认构造。
析构函数
析构函数和构造函数功能相反,析构函数不是对对象本身的销毁,而是对对象中资源的清理工作。
如果没有资源需要释放,就不需要析构函数了。
特征:
- 析构函数名是在类名前加上字符 ~。
- . 无参数无返回值类型。
- 一个类只能有一个析构函数。若未显式定义,系统会自动生成默认的析构函数。注意:析构函数不能重载
- 对象生命周期结束时,C++编译系统系统自动调用析构函数。
- 跟构造函数类似,我们不写编译器自动生成的析构函数对内置类型成员不做处理,自定义类型成员会调用他的析构函数。
- 如果类没有申请资源,析构可以不用写。如果没有写析构,也会自动调用析构函数。
- 如果有资源申请,一定要写析构函数,否则会造成内存泄漏。
#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
Stack(int n = 4)
{
_a = (STDataType*)malloc(sizeof(STDataType) * n);
if (nullptr == _a)
{
perror("malloc申请空间失败");
return;
}
_capacity = n;
_top = 0;
}
// ...
~Stack()
{
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
STDataType* _a;
size_t _capacity;
size_t _top;
};
// 两个Stack实现队列
class MyQueue
{
public:
// 编译器默认生成MyQueue的析构函数调用了Stack的析构,释放的Stack内部的资源
// 显示写析构,也会自动调用Stack的析构
~MyQueue()
{
cout << "~MyQueue()" << endl;
}
private:
Stack pushst;
Stack popst;
//int size;
};
int main()
{
MyQueue mq;
//stack st1;
//stack st2;
return 0;
}
拷贝构造函数
什么是拷贝构造:
如果一个构造函数的第一个参数是自身类类型的引用,且额外的参数都有默认值,则此构造函数也叫做拷贝构造函数,也就是说拷贝构造函数是一个特殊的构造函数。
特征:
- 拷贝构造函数是构造函数的一个重载形式。
- 拷贝构造函数的第一个参数必须是类类型对象的引用,使用传值方式编译器直接报错,因为会引发无穷递归调用。
像这样:
如果拷贝构造函数的参数是通过值传递的,那么编译器会尝试通过调用拷贝构造函数来复制实参。这意味着在拷贝构造函数内部,每当需要创建一个新对象时(在这种情况下是为了将 other 作为实参传递),编译器又会调用拷贝构造函数。这会导致一个无限递归的调用序列,因为每次调用都需要再次调用拷贝构造函数。
通过使用引用,特别是常量引用,我们避免了这种递归调用,因为引用只是对象的别名,不需要创建对象的副本。
#include<iostream>
using namespace std;
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
// error C2652: “Date”: 非法的复制构造函数: 第一个参数不应是“Date”
// Date d2(d1)
Date(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;
};
- C++规定自定义类型对象进行拷贝行为必须调用拷贝构造,所以这里自定义类型传值传参和传值返回都会调用拷贝构造来完成。
- . 若未显式定义拷贝构造,编译器会生成默认的拷贝构造函数。 自动生成的拷贝构造对内置类型成员变量会完成值拷贝/浅拷贝(一个字节一个字节的拷贝),对自定义类型成员变量会调用他的拷贝构造。
浅拷贝会出很大的问题:
浅拷贝并不申请新的资源,导致析构两次,程序崩溃。最好自己动手深拷贝,这个不是重点我就不细说了。
- 传值返回会产生一个临时对象调用拷贝结构,传值引用返回,返回的是返回对象的别名(引用),没有产生拷贝。但是如果返回对象是当前局部域的一个局部对象,函数结束就销毁了,那么使用引用返回是有问题的,这时的引用相当于一个野引用,类似野指针。传引用返回可以减少拷贝,但是一定要确保返回对象,在当前函数结束后还在,才能用引用返回。
赋值运算符重载
运算符重载
- 当运算符被用于类类型的对象时,C++语言允许我们通过运算符重载的形式指定新的含义。C++规定类类型对象使用运算符时,必须转换成调用对应运算符重载,若没有对应的运算符重载,则会编译报错。
- 运算符重载是具有特名字的函数,他的名字是由operator和后面要定义的运算符共同构成。和其他函数一样,它也具有其返回类型和参数列表以及函数体。
- 重载运算符函数的参数个数和该运算符作用的运算对象数量一样多。一元运算符有一个参数,二元运算符有两个参数,二元运算符的左侧运算对象传给第一个参数,右侧运算对象传给第二个参数。
- 如果一个重载运算符函数是成员函数,则它的第一个运算对象默认传给隐式的this指针,因此运算符重载作为成员函数时,参数比运算对象少一个。
- 运算符重载以后,其优先级和结合性与对应的内置类型运算符保持一致。
- 不能通过连接语法中没有的符号来创建新的操作符:比如operator@。
//bool operator==(Date d1, Date d2)
//{
// return d1._year == d2._year
// && d1._month == d2._month
// && d1._day == d2._day;
//}
bool operator==(Date d2)
{
return _year == d2._year
&& _month == d2._month
&& _day == d2._day;
}
int main()
{
Date x1(2024, 7, 10);
Date x2(2024, 7, 11);
//operator==(x1, x2);
//x1 == x2;
x1.operator==(x2);
x1 == x2;
return 0;
}
注意,以上5个运算符不能重载。- 重载操作符至少有一个类类型参数,不能通过运算符重载改变内置类型对象的含义,如: int operator+(int x,int y)。
- 一个类需要重载哪些运算符,是看哪些运算符重载后有意义, 比如Date类重载operator-就有意 义,但是重载operator+就没有意义。
bool operator==(const Date& d1, const Date& d2)
{
return d1._year == d2._year
&& d1._month == d2._month
&& d1._day == d2._day;
}
int main()
{
// 运算符重载函数可以显示调用
operator==(d1, d2);
// 编译器会转换成 operator==(d1, d2);
d1 == d2;
return 0;
}
赋值运算符重载
赋值运算符重载是一个默认成员函数,用于完成两个已经存在的对象直接的拷贝赋值,这里要注意跟拷贝构造区分,拷贝构造用于一个对象拷贝初始化给另一个要创建的对象。
赋值运算符重载的特点:
1.赋值运算符重载是一个运算符重载,规定必须重载为成员函数。赋值运算重载的参数建议写成
const 当前类类型引用,否则会传值传参会有拷贝
2.有返回值,且建议写成当前类类型引用,引用返回可以提高效率,有返回值目的是为了支持连续赋
值场景。
3.没有显式实现时,编译器会自动生成一个默认赋值运算符重载,默认赋值运算符重载行为跟默认拷贝构造函数类似,对内置类型成员变量会完成值拷贝/浅拷贝(一个字节一个字节的拷贝),对自定义类型 damen成员变量会调用他的拷贝构造。
const成员函数
将const修饰的“成员函数”称之为const成员函数,const修饰类成员函数,实际修饰该成员函数
隐含的this指针,表明在该成员函数中不能对类的任何成员进行修改。
- 类内声明
类型 函数名(参数列表) const
{
函数体
}- 类外定义
类型 类名::函数名(参数列表) const
{
函数体
}
特点:
- const成员函数内只能读取类的数据成员,无法修改类的数据成员,否者编译器会报错。
class func
{
//默认是private
int x;
int y;
public:
func(int xp = 0, int yp = 0)
{
x = xp;
y = yp;
}
//const成员函数内无法修改类的数据成员,否者编译器会报错
void print() const
{
x = 5;//试图修改x 将引发编译器报错
cout << "x:" << x << "y:" << y << endl;
}
};
即const成员函数不能修改类中的变量
- const成员函数内,不能调用其他非const成员函数
class func
{
//默认是private
int x;
int y;
public:
func(int xp = 0, int yp = 0)
{
x = xp;
y = yp;
}
void Print2()
{
cout << "x:" << x << "y:" << y << endl;
}
//const成员函数内无法修改类的数据成员,否者编译器会报错
void Print() const
{
//x=5;//试图修改成员变量 将引发编译器报错
Print2(); //试图调用非const成员 引发编译器报错
cout << "x:" << x << "y:" << y << endl;
}
};
希望这篇博客对你有所帮助!!!