默认成员函数
1.类的六个默认成员函数
这是一个空类,看起来什么成员都没有
class Date
{
}
空类中真的什么都没有吗?
答:并不是,任何类在什么都不写时,编译器会自动生成以下6个默认成员
函数。
默认成员函数:用户没有显式实现,编译器会生成的成员函数称为默认成员函数。
2.构造函数
2.1 概念
构造函数是一个特殊的成员函数,名字与类名相同,创建类类型对象时由编译器自动调用,以保证
每个数据成员都有 一个合适的初始值,并且在对象整个生命周期内只调用一次。
2.2 特性
构造函数是特殊的成员函数,需要注意的是,构造函数虽然名称叫构造,但是构造函数的主要任
务并不是开空间创建对象,而是初始化对象。
特征如下:
- 函数名与类名相同。
- 无返回值。
- 对象实例化时编译器自动调用对应的构造函数。
- 构造函数可以重载。
- 如果类中没有显式定义构造函数,则C++编译器会自动生成一个无参的默认构造函数,一旦
用户显式定义编译器将不再生成。
用日期类举例:
class Date
{
public:
//无参构造函数
Date()
{
}
//带参构造函数
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void printf()
{
cout << _year << "年" << " " << _month << "月" << " " << _day << "日" << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
//调用无参构造函数
Date d1;
//调用带参构造哈数
Date d2(2024,4,13);
d1.printf();
return 0;
}
注意:如果通过无参构造函数创建对象时,对象后面不用跟括号,否则就成了函数声明
对比以下两个:
// 错误的 调用无参构造函数的 实例化
Date d1();
//上面的实例化像不像下列的形式
Dete d1()
{
}
//编译器无法辨别 Date d1()是函数声明还是定义函数
编译器生成构造函数和自定义构造函数只能存在一个:
class Date
{
public:
//自己写构造函数后就不会再调用编译器的构造函数
Date(int year , int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
2.3 内置类型和自定义类型
关于编译器生成的默认成员函数,很多同学会有疑惑:不实现构造函数的情况下,编译器会
生成默认的构造函数。但是看起来默认构造函数又没什么用?d对象调用了编译器生成的默
认构造函数,但是d对象_year/_month/_day,依旧是随机值。也就说在这里编译器生成的
默认构造函数并没有什么用??
解答:C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类
型,如:int/char…,自定义类型就是我们使用class/struct/union等自己定义的类型,看看
下面的程序,就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员
函数。
class test
{
public:
test()
{
cout << "test()" << endl;
_a = 0;
_b = 0;
}
private:
int _a;
int _b;
};
class Date
{
public:
private:
//内置类型
int _year;
int _month;
int _day;
//自定义类型
test t;
};
int main()
{
Date d;
return 0;
}
注意:C++11 中针对内置类型成员不初始化的缺陷,又打了补丁,即:内置类型成员变量在
类中声明时可以给默认值。
class Date
{
public:
private:
//缺省值
int _year = 2024;
int _month = 4 ;
int _day = 13;
};
2.4 无参构造函数和全缺省构造函数
无参的构造函数和全缺省的构造函数都称为默认构造函数,并且默认构造函数只能有一个。
注意:无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数,都可以认为
是默认构造函数。
下面的函数调用会出现报错:error C2668: “Date::Date”: 对重载函数的调用不明确
class Date
{
public:
Date()
{
_year = 2024;
_month = 4;
_day = 13;
}
Date(int year = 2024, int month = 4, int day = 13)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year ;
int _month ;
int _day ;
};
int main()
{
Date d;
return 0;
}
// error C2668: “Date::Date”: 对重载函数的调用不明确
3.析构函数
3.1概念
通过前面构造函数的学习,我们知道一个对象是怎么来的,那一个对象又是怎么没呢的?
析构函数:与构造函数功能相反,析构函数不是完成对对象本身的销毁,局部对象销毁工作是由
编译器完成的。而对象在销毁时会自动调用析构函数,完成对象中资源的清理工作。
3.2特性
析构函数是特殊的成员函数,其特性如下:
- 析构函数名是在类名前加上字符 ~。
- 无参数无返回值类型。
- 一个类只能有一个析构函数。若未显式定义,系统会自动生成默认的析构函数。注意:析构
函数不能重载。 - 对象生命周期结束时,C++编译系统系统自动调用析构函数。
- 如果类中没有申请资源时,析构函数可以不写,直接使用编译器生成的默认析构函数,比如
Date类;有资源申请时,一定要写,否则会造成资源泄漏,比如Stack类。
关于编译器自动生成的析构函数,是否会完成一些事情呢?下面的程序我们会看到,编译器
生成的默认析构函数,对自定类型成员调用它的析构函数
class Test
{
public:
//构造函数
Test()
{
cout << "Test()" << endl;
a = 0;
b = 0;
}
//析构函数
~Test()
{
cout << "~Test()" << endl;;
}
private:
int a;
int b;
};
class Date
{
public:
private:
//内置类型
int _year;
int _month;
int _day;
//自定义类型
Test _t;
};
int main()
{
Date d;
return 0;
}
程序运行结束后输出:~Time()
在main方法中根本没有直接创建Time类的对象,为什么最后会调用Time类的析构函数?
答:main方法中创建了Date对象d,而d中包含4个成员变量,其中_year, _month,
_day三个是 _t
内置类型成员,销毁时不需要资源清理,最后系统直接将其内存回收即可;而_t是Test类对
象,所以在 d销毁时,要将其内部包含的Test类的_t对象销毁,所以要调用Test类的析构函数。但是:
main函数中不能直接调用Test类的析构函数,实际要释放的是Date类对象,所以编译器会调用Date
类的析构函数,而Date没有显式提供,则编译器会给Date类生成一个默认的析构函数,目的是在其内部调用Test类的析构函数,即当Date对象销毁时,要保证其内部每个自定义对象都可以正确销毁
main函数中并没有直接调用T类析est构函数,而是显式调用编译器为Date类生成的默认析
构函数
注意:创建哪个类的对象则调用该类的析构函数,销毁那个类的对象则调用该类的析构函数
4.拷贝构造函数
4.1 概念
现实生活中比照一个物品做出一个相同的叫做复制
那在创建对象时,可否创建一个与已存在对象一某一样的新对象呢?
拷贝构造函数:只有单个形参,该形参是对本类类型对象的引用(一般常用const修饰),在用已存
在的类类型对象创建新对象时由编译器自动调用
4.2 特征
拷贝构造函数也是特殊的默认成员函数,其特征如下:
- 拷贝构造函数是构造函数的一个重载形式。
- 拷贝构造函数的参数只有一个且必须是类类型对象的引用,使用传值方式编译器直接报错,
因为会引发无穷递归调用。
class Date
{
public:
Date(int year = 2024, int month = 4, int day = 14)
{
_year = year;
_month = month;
_day = day;
}
//Date(Date d) 错误写法,会造成无限循环
//Date(Date& d) 取引用,正确写法
Date(const Date& d) //const,标准写法
{
_year = d._year;
_month = d._month;
_day = d._day;
}
~Date()
{
_year = 0;
_month = 0;
_day = 0;
}
private:
//内置类型
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2025,1,1);
Date d2(d1);//拷贝构造
return 0;
}
死循环解释图:
- 若未显式定义,编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按
字节序完成拷贝,这种拷贝叫做浅拷贝,或者值拷贝。
class Test
{
public:
Test()
{
cout << "Test()" << endl;
_a = 0;
_b = 0;
}
Test(const Test& t)
{
cout << "Test(const Test& t)" << endl;
_a = t._a;
_b = t._b;
}
~Test()
{
cout << "~Test()" << endl;;
}
private:
int _a;
int _b;
};
class Date
{
public:
Date(int year = 2024, int month = 4, int day = 14)
{
_year = year;
_month = month;
_day = day;
}
~Date()
{
_year = 0;
_month = 0;
_day = 0;
}
private:
//内置类型
int _year;
int _month;
int _day;
//自定义类型
Test _t;
};
int main()
{
Date d1(2025, 1, 1);
Date d2(d1);
return 0;
用已经存在的d1拷贝构造d2,此处会调用Date类的拷贝构造函数,但Date类并没有显式定义拷贝构造函数,则编译器会给Date类生成一个默认的拷贝构造函数
注意:在编译器生成的默认拷贝构造函数中,内置类型是按照字节方式直接拷贝的,而自定
义类型是调用其拷贝构造函数完成拷贝的。
- 编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了,还需要自己显式实现吗?
当然像日期类这样的类是没必要的。那么下面的类呢?验证一下试试?
// 这里会发现下面的程序会崩溃掉?这里就需要我们用深拷贝去解决。
typedef int DataType;
class Stack
{
public:
// 构造函数
Stack(size_t capacity = 10)
{
_array = (DataType*)malloc(capacity * sizeof(DataType));
if (nullptr == _array)
{
perror("malloc fail");
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;
int _size;
int _capacity;
};
int main()
{
Stack s1;
s1.Push(1);
s1.Push(2);
s1.Push(3);
s1.Push(4);
Stack s2(s1);
return 0;
}
崩溃原因:两个对象中的指针指向同一个地址,程序运行结束时会先调用一个对象的析构函数,再调用另一个对象的析构函数,通知崩溃在此析构函数中发生:
注意:类中如果没有涉及资源申请时,拷贝构造函数是否写都可以;一旦涉及到资源申请
时,则拷贝构造函数是一定要写的,否则就是浅拷贝。
4.3 拷贝构造函数典型调用场景
- 使用已存在对象创建新对象
- 函数参数类型为类类型对象
- 函数返回值类型为类类型对象
为了提高程序效率,一般对象传参时,尽量使用引用类型,返回时根据实际场景,能用引用
尽量使用引用。
4.4拷贝构造特殊形式
建议先看下面的赋值运算符重载再来学习
- 拷贝构造
//拷贝构造
Date d1;
Date d2(d1);
Date d3 = d1;
//这个也是拷贝构造,从定义理解
//拷贝构造是 一个对象初始化另一个对象
Date d4 = d1 + 1;
Date d5 ( d1 + 1);
- 赋值运算符重载
//赋值运算符载
Date d1;
Date d2;
d2 = d1 + 1;
5.赋值运算符重载
5.1 运算符重载
简单的说,原本只能整数和浮点数用运算符进行运算,现在自定义对象也能用运算符运算。
C++为了增强代码的可读性引入了运算符重载,运算符重载是具有特殊函数名的函数,也具有其
返回值类型,函数名字以及参数列表,其返回值类型与参数列表与普通的函数类似。
函数名字为:关键字operator后面接需要重载的运算符符号。
函数原型:返回值类型 operator操作符(参数列表)
注意:
- 不能通过连接其他符号来创建新的操作符:比如operator@
- 重载操作符必须有一个类类型参数
- 用于内置类型的运算符,其含义不能改变,例如:内置的整型+,不 能改变其含义
.* :: sizeof ?: . 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。
- 作为类成员函数重载时,其形参看起来比操作数数目少1,因为成员函数的第一个参数为隐
藏的this
// operator 在全局变量
class Date
{
public:
Date(int year = 2024, int month = 4, int day = 14)
{
_year = year;
_month = month;
_day = day;
}
Date(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
~Date()
{
_year = 0;
_month = 0;
_day = 0;
}
//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;
}
int main()
{
Date d1(2025, 1, 1);
Date d2;
cout << (d2 == d1) << endl;
return 0;
}
// 内置成员函数
class Date
{
public:
Date(int year = 2024, int month = 4, int day = 14)
{
_year = year;
_month = month;
_day = day;
}
Date(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
// bool operator==(Date* this, const Date& d2)
// 这里需要注意的是,左操作数是this,指向调用函数的对象
bool operator==(const Date& d)
{
return _year == d._year
&& _month == d._month
&& _day == d._day;
}
~Date()
{
_year = 0;
_month = 0;
_day = 0;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2025, 1, 1);
Date d2;
cout << (d2 == d1) << endl;
return 0;
}
5.2 赋值运算符重载
1. 赋值运算符重载格式:
- 参数类型:const T&,传递引用可以提高传参效率
- 返回值类型:T&,返回引用可以提高返回的效率,有返回值目的是为了支持连续赋值
- 检测是否自己给自己赋值。
- 返回*this :要复合连续赋值的含义。
class Date
{
public:
Date(int year = 2024, int month = 4, int day = 14)
{
_year = year;
_month = month;
_day = day;
}
//复制运算符重载 Date对象赋值给Date对象
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;
};
2. 赋值运算符只能重载成类的成员函数不能重载成全局函数
class Date
{
public:
Date(int year = 2024, int month = 4, int day = 14)
{
_year = year;
_month = month;
_day = day;
}
//private:
int _year;
int _month;
int _day;
};
// 赋值运算符重载成全局函数,注意重载成全局函数时没有this指针了,需要给两个参数
Date& operator=(Date& d1, const Date& d2)
{
d1._year = d2._year;
d1._month = d2._month;
d1._day = d2._day;
}
int main()
{
return 0;
}
// 编译失败:
// error C2801: “operator =”必须是非静态成员
原因:赋值运算符如果不显式实现,编译器会生成一个默认的。此时用户再在类外自己实现
一个全局的赋值运算符重载,就和编译器在类中生成的默认赋值运算符重载冲突了,故赋值
运算符重载只能是类的成员函数。
我们可以重载赋值运算符。不论形参的类型是什么,赋值运算符都必须定义为成员函数
3. 用户没有显式实现时,编译器会生成一个默认赋值运算符重载,以值的方式逐字节拷贝。
注意:内置类型成员变量是直接赋值的,而自定义类型成员变量需要调用对应类的赋值运算符
重载完成赋值。
既然编译器生成的默认赋值运算符重载函数已经可以完成字节序的值拷贝了,还需要自己实
现吗?
答:像日期类这样的类是没必要的。
那么下面的类呢?验证一下试试?
// 这里会发现下面的程序会崩溃掉?这里就需要我们以后讲的深拷贝去解决。
typedef int DataType;
class Stack
{
public:
Stack(size_t capacity = 10)
{
_array = (DataType*)malloc(capacity * sizeof(DataType));
if (nullptr == _array)
{
perror("malloc fail");
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;
}
注意:如果类中未涉及到资源管理,赋值运算符是否实现都可以;一旦涉及到资源管理则必
须要实现。
5.3 前置++和后置++重载
class Date
{
public:
Date(int year = 2024, int month = 4, int day = 14)
{
_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;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d;
Date d1(2024, 1, 1);
d = d1++; //d(2024,1,1) d1(2024,1,2)
d = ++d1; //d1(2024,1,3) d(2024,1,3)
return 0;
}
6.日期类
class Date
{
public:
//构造函数
Date(int year, int month, int day)
{
//检查输入格式
Check(year, month, day);
_year = year;
_month = month;
_day = day;
}
//打印
void printf()
{
cout << _year << "年" << " " << _month << "月" << " " << _day << "日" << endl;
}
//获得某一月的天数
int GetMonthDay(int year, int month)
{
int arr[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31,30,31 };
if (month == 2 && (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)))
{
return 29;
}
else
{
return arr[month];
}
}
//检查输入格式是否正确
void Check(int year, int month, int day)
{
if (month > 12 || month <= 0)
{
cout << "非法输入,请重新输入" << endl;
return;
}
if (GetMonthDay(year, month) < day)
{
cout << "非法输入,请重新输入" << endl;
return;
}
}
//Date类可以不写拷贝构造函数
Date(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
//Date + 天数
Date operator+(const int day)
{
Date tmp(*this);
tmp += day;
return tmp;
}
//Date += 天数
Date& operator+=(const int day)
{
_day += day;
while (_day > GetMonthDay(_year, _month))
{
_day -= GetMonthDay(_year, _month);
++_month;
if (_month > 12)
{
_month = 1;
_year++;
}
}
return *this;
}
//Date -=天数
Date& operator-= (int day)
{
_day -= day;
while (_day <= 0)
{
--_month;
if (_month <= 0)
{
_month = 12;
--_year;
}
_day += GetMonthDay(_year, _month);
}
return *this;
}
//Date - 天数
Date operator-(int day)
{
Date tmp(*this);
tmp -= day;
return tmp;
}
//Date类可以不写赋值运算符重载
Date& operator=(const Date& d)
{
if (this != &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
return *this;
}
//前置++
Date& operator++()
{
return *this += 1;
}
//后置++
Date operator++(int)
{
Date tmp(*this);
*this += 1;
return tmp;
}
//前置--
Date& operator--()
{
return *this -= 1;
}
//后置--
Date operator--(int)
{
Date tmp(*this);
*this -= 1;
return tmp;
}
//Date ==
bool operator==(const Date& d)
{
return _year == d._year
&& _month == d._month
&& _day == d._day;
}
//Date >
bool operator>(const Date& d)
{
if (_year > d._year)
{
return true;
}
if (_year == d._year && _month > d._month)
{
return true;
}
if (_year == d._year && _month == d._month && _day > d._day)
{
return true;
}
return false;
}
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 || *this > d;
}
bool operator<=(const Date& d)
{
return *this == d || *this < d;
}
//析构函数
~Date()
{
_year = 0;
_month = 0;
_day = 0;
}
private:
int _year;
int _month;
int _day;
};
7.const 成员
将const修饰的“成员函数”称之为const成员函数,const修饰类成员函数,实际修饰该成员函数
隐含的this指针,表明在该成员函数中不能对类的任何成员进行修改。
请思考下面的几个问题:
- const对象可以调用非const成员函数吗?
- 非const对象可以调用const成员函数吗?
- const成员函数内可以调用其它的非const成员函数吗?
- 非const成员函数内可以调用其它的const成员函数吗?
8. 取地址及const取地址操作符重载
这两个默认成员函数一般不用重新定义 ,编译器默认会生成。
class Date
{
public:
Date* operator&()
{
return this;
}
const Date* operator&()const
{
return this;
}
private:
int _year; // 年
int _month; // 月
int _day; // 日
};
这两个运算符一般不需要重载,使用编译器生成的默认取地址的重载即可,只有特殊情况,才需
要重载,比如想让别人获取到指定的内容!