类的六个默认函数
如果一个类中什么成员都没有,这个类就叫做空类
但是类中什么都没有吗?答案是否定的,类中什么都没有的时候,编译器会默认生成六个默认成员函数
默认成员函数:用户没有显示实现(用户没有写),编译器会自动实现的函数
构造函数
构造函数虽然里面有一个构造的词语,但是和构造没有任何关系,它的作用是对数据成员进行初始化
构造函数的引入
下面有一段代码
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 date1;
date1.init(2024, 8, 15);
date1.print();
return 0;
}
上面的代码定义的一个日期类,下面对代码进行两点说明:
1.为什么我们定义变量的时候要在前面加一个" _",比如,_year,_month,_day
答:就用上面的代码来解释,比如上面的初始化函数,里面的形参数是year,month,day,如果你成员变量也写成year,month,day的话,形参写成别的单词你又不好辨别
2.关于构造函数的引入
有的时候我们会忘记对类进行初始化,比如我们学的数据结构中的栈和队列,如果忘记初始化了, 你在去插入一个值,程序就会崩溃,这时候就显示出构造函数的作用了,会帮你自动初始化成员变量
构造函数的特性
构造函数是特殊的成员函数,需要注意的是,构造函数虽然名称叫构造,但是构造函数的主要任
务并不是开空间创建对象,而是初始化对象。
其特征如下:
1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。
class Date
{
public:
Date() //这是一个构造函数
{
_year = 1;
_month = 1;
_day = 1;
}
void print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date date1;
date1.print();
return 0;
}
运行结果:
从上面的代码运行结果来看,当对类进行实例化的时候,会自动调用构造函数来对数据成员进行初始化
class Date
{
public:
Date() //这是一个构造函数(无参构造函数)
{
_year = 1;
_month = 1;
_day = 1;
}
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 date1;
date1.print();
Date date2(2024, 8, 15); //有参构造函数的,在实例化的时候在后面加上要初始化的值
//即可,调用无参构造函数的话,什么也不用写,正常实例话
//对象就行
date2.print();
return 0;
}
运行结果:
5. 如果类中没有显式定义构造函数,则C++编译器会自动生成一个无参的默认构造函数,一旦
用户显式定义编译器将不再生成。
比如下面的:
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 date1;
date1.print();
return 0;
}
你如果把上面你写的构造函数的代码注释掉,程序是会正常运行的,但是如果你不注释掉,程序会报错,因为你写了构造函数,编译器不会生成无参构造函数,你调用的方式又不是有参函数的调用的方式
6. 关于编译器生成的默认成员函数,很多童鞋会有疑惑:不实现构造函数的情况下,编译器会
生成默认的构造函数。但是看起来默认构造函数又没什么用?d对象调用了编译器生成的默
认构造函数,但是d对象_year/_month/_day,依旧是随机值。也就说在这里编译器生成的
默认构造函数并没有什么用?
解答:C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类
型,如:int/char...,自定义类型就是我们使用class/struct/union等自己定义的类型,看看
下面的程序,就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员
函数
class Time
{
public:
Time()
{
cout << "Time()" << endl;
_hour = 0;
_minute = 0;
_second = 0;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
private:
// 基本类型(内置类型)
int _year;
int _month;
int _day;
// 自定义类型
Time _t;
};
int main()
{
Date d;
return 0;
}
运行结果:
7.C++针对编译器生成的默认构造函数对于内置类型不初始化做了补丁,即就是内置类型在
声明的时候可以给一个默认值
class Date
{
public:
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year=1;
int _month=1;
int _day=1;
};
int main()
{
Date d;
d.Print();
return 0;
}
运行结果:
7. 无参的构造函数和全缺省的构造函数都称为默认构造函数,并且默认构造函数只能有一个。
注意:无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数,都可以认为
是默认构造函数
总结
1.一般情况下我们都要自己写一个默认构造函数,因为有的编译器自己生成构造函数对于内置类型是不做处理的,还是随机值
2.有的情况下不用自己写,比如
class Stack //定义一个栈
{
public:
//这里自己要实现一个构造函数
private:
int *_arr;
int _size;
int _capacity;
};
class MyQueue
{
private:
Stack st1;
Stack st2;
};
上面的虽然不用自己写,但是在嵌套的里面还是要写一个,也就是说,MyQueue里面不用写,但是Stack里面是要写的,因为Stack里面也有内置类型,不写的话有的编译器是不做处理的
析构函数
在学习数据结构的时候,比如我们的栈和队列,有时候老是忘记调用Destory函数,在C语言中要担心这个问题,但是在C++中,你是不用担心这个问题的,因为C++的析构函数会自动帮你处理这个问题
析构函数和构造函数的功能正好相反,是自动对对象进行销毁,当程序要结束的时候,(一般情况下一语句是return 的时候)就会调用默认的析构函数
析构函数的特性
1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值类型。
3. 一个类只能有一个析构函数。若未显式定义,系统会自动生成默认的析构函数。注意:析构
函数不能重载
4. 对象生命周期结束时,C++编译系统系统自动调用析构函数。
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);
}
5. 关于编译器自动生成的析构函数,是否会完成一些事情呢?下面的程序我们会看到,编译器
生成的默认析构函数,对自定类型成员调用它的析构函数
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;
}
运行结果:
总结
1.有资源需要清理的时候需要自己写析构函数,比如: 栈和队列,里面的指针类型在堆上面开辟的,程序结束后需要手动去清理的
2.有的类里面不需要写析构函数
a.没有资源需要清理的,比如日期类的,里面定义了int double类的,程序结束后会自动销毁的
b.内置类型没有需要清理的,剩下的是自定义类型,但是要看自定义类型里面是否需要写
拷贝构造函数
特征
1. 拷贝构造函数是构造函数的一个重载形式
.2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用,使用传值方式编译器直接报错,
因为会引发无穷递归调用。
class Date
{
public:
Date(int year=1,int month=1,int day=1)
{
_year = year;
_month = month;
_day = day;
}
// Date(const Date d) //不可以这样写,会引发无穷递归
Date(const Date& d) //可以这样写
{
cout << "Date(const Date&d)" << endl;
_year = d._year;
_month = d._month;
_day = d._day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
Date d2(d1); //这样写是拷贝构造
//Date d2=d1; //这样写也是拷贝构造
return 0;
}
运行结果:
3.对于自定义类型,函数传值传参会调用它的拷贝构造
class Date
{
public:
Date(int year=1,int month=1,int day=1)
{
_year = year;
_month = month;
_day = day;
}
Date(const Date& d)
{
cout << "Date(const Date&d)" << endl;
_year = d._year;
_month = d._month;
_day = d._day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
void func(Date d)
{
d.Print();
}
int main()
{
Date d1;
//Date d2(d1);
//Date d2=d1;
func(d1);
return 0;
}
函数运行结果:
这也能解释上面为什么说拷贝构造传递参要采用引用的方式,而采用传值的方式会引发无穷递归,
4. 若未显式定义,编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按
字节序完成拷贝,这种拷贝叫做浅拷贝,或者值拷贝。
class Date
{
public:
Date(int year=1,int month=1,int day=1)
{
_year = year;
_month = month;
_day = day;
_arr = &day;
}
~Date()
{
free(_arr);
_arr = nullptr;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
int* _arr;
};
int main()
{
Date d1;
Date d2(d1);
return 0;
}
程序运行结果:
从运行结果来看,程序崩溃了,因为我们没有写拷贝构造函数,编译器自动生成的拷贝构造函数是是按值拷贝,所以这里创建的两个对象的_arr指向同一块空间,程序结束的时候会析构两次,但是第一次指针指向的空间已经为空了,第二次去释放一个空的空间程序自然会崩溃
注意:类中如果没有涉及资源申请时,拷贝构造函数是否写都可以;一旦涉及到资源申请
时,则拷贝构造函数是一定要写的,否则就是浅拷贝
所以这里我们应该写一个深拷贝,只需要申请一个和被拷贝对象大小一样的空间就行了,我们以一个栈为例
Stack(const Stack& st)
{
_array = (DataType*)malloc(sizeof(DataType) * st._capacity);
if (NULL == _array)
{
perror("malloc申请空间失败!!!");
return;
}
memcpy(_array, st._array, sizeof(DataType) * st._size);
_size = st._size;
_capacity = st._capacity;
}
总结
上面第二点:自定义里面有自定义类型的,如果第二个自定义类型里面涉及到资源申请的,同样需要在第二个自定义里面写拷贝构造,只是第一个不需要而已
赋值运算符重载
运算符号重载
C++为了增强代码的可读性引入了运算符重载,运算符重载是具有特殊函数名的函数,也具有其
返回值类型,函数名字以及参数列表,其返回值类型与参数列表与普通的函数类似。
函数名字为:关键字operator后面接需要重载的运算符符号。
函数原型:返回值类型 operator操作符(参数列表)
比如下面的
class Date
{
public:
Date(int year, int month, int day)
{
_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;
}
int main()
{
Date d1(2024, 8, 20);
Date d2(2024, 8, 21);
//隐式调用,两种方式都行
cout << operator==(d1, d2) << endl;
//转换调用,实际上就是operator==()函数
cout << (d1 == d2) << endl;
return 0;
}
运行结果:
1. 其实从上面不难看出,运算符重载极大的增加了代码的可读性,以前写相等的函数名字可能写
compare,equal甚至组合起来的单词,但是,如果有人不认识这些单词怎么办,所以,运算符重载极大的增强了代码的可读性
2.上面的函数在外面无法访问类里面的元素,有以下几个解决方案:
1、提供这些成员get函数和set函数,比如
int getyear()
{
return _year;
} //当然,这个函数是要写在类里面的
2、友元 ,后面再讲
3、重载为成员函数(一般使用这种)
注意
1.不能通过连接其他符号来创建新的操作符:比如operator@
2.重载操作符必须有一个类类型参数
3.用于内置类型的运算符,其含义不能改变,例如:内置的整型+,不 能改变其含义
4.作为类成员函数重载时,其形参看起来比操作数数目少1,因为成员函数的第一个参数为隐
藏的this
5. .* :: sizeof ?: . 注意以上5个运算符不能重载。
除了上面的第4点,其余的第五点没有什么讲的
第四点举例子:
class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
bool operator==(const Date & d)
{
return _year == d._year && _month == d._month
&& _day == d._day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2024, 8, 20);
Date d2(2024, 8, 21);
cout << (d1 == d2) << endl;
cout << d1.operator==(d2) << endl;
return 0;
}
代码说明:
d1.operator==(d2),其中,d1是第一个参数,d2是第二个参数,还有,上面的函数相当于
d1.operator(Date*this,const Date&d2)
拷贝构造和赋值构造的区别
赋值构造又叫赋值重载
下面,用一段代码来说明两者之间的区别:
int main()
{
Date d1(2024, 4, 14);
// 拷贝构造
// 一个已经存在的对象,拷贝给另一个要创建初始化的对象
Date d2(d1);
Date d3 = d1;
Date d4(2024, 5, 1);
// 赋值拷贝/赋值重载
// 一个已经存在的对象,拷贝赋值给另一个已经存在的对象
d1 = d4;
return 0;
}
函数的引用返回和直接返回
Date func()
{
Date d(2024, 8, 20);
return d;
} //直接返回
Date&func()
{
Date d(2024, 8, 20);
return d;
} //引用返回,返回的是d的别名
直接返回
直接返回,返回的是值的一份临时拷贝,每次调用函数的时候,都会建立函数的栈帧,等到函数结束的时候,里面的东西也会被销毁掉
引用返回
通过前面的学习,我们都知道,引用就是对变量起一个外号,对引用怎么操作原变量也就怎么操作,如果返回的是其别名,但是函数栈帧已经销毁了,所以接收到的值已经不是之前的那个东西了
class Date
{
public:
Date(int year, int month, int day)
{
cout << "Date(int year, int month, int day)" << endl;
_year = year;
_month = month;
_day = day;
}
Date(const Date& d)
{
cout << "Date(const Date&d)" << endl;
}
bool operator==(const Date & d)
{
return _year == d._year && _month == d._month
&& _day == d._day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
Date&func()
{
Date d(2024, 8, 20);
return d;
}
int main()
{
Date ref=func();
ref.Print();
return 0;
}
程序运行结果:
通过运行结果的第三行,我们能够看见,打印的是随机值,可以说明的是,该变量已经被销毁了
总结:
赋值重载函数
1. 赋值运算符重载格式
参数类型:const T&,传递引用可以提高传参效率
返回值类型:T&,返回引用可以提高返回的效率,有返回值目的是为了支持连续赋值
检测是否自己给自己赋值
返回*this :要复合连续赋值的含义
int i=0,j=1,k=2;
i=j=k;
从左到右边赋值,j=k返回的类型是int ,这是规定,同样,在类中,如果要连续赋值的话,必须要写一个返回类型,比如下面的,但是,如果是只有两个对象,可写可不写
上面的函数,其实
Date operator=(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
return *this;
}
int main()
{
Date d1(2022, 2, 2);
Date d2(2024, 2, 4);
d2 = d1;
d2.Print();
return 0;
}
//为了节省面积,其余的这里就不实现了
运行结果:
2. 赋值运算符只能重载成类的成员函数不能重载成全局函数
原因:赋值运算符如果不显式实现,编译器会生成一个默认的。此时用户再在类外自己实现
一个全局的赋值运算符重载,就和编译器在类中生成的默认赋值运算符重载冲突了,故赋值
运算符重载只能是类的成员函数。
3. 用户没有显式实现时,编译器会生成一个默认赋值运算符重载,以值的方式逐字节拷贝。注
意:内置类型成员变量是直接赋值的,而自定义类型成员变量需要调用对应类的赋值运算符
重载完成赋值
这里和之前的几个默认函数一样
4.如果类中涉及到资源管理,那么需要自己写