系列文章目录
前言
如果一个类中什么成员都没有,简称空类。但是空类中真的是什么都没有吗?并不是的,任何一个类在我们不写的情况下会都会自动生成六个默认成员函数。
- 构造函数
- 析构函数
- 拷贝构造函数
- 赋值运算符重载
- const成员
- const修饰的取地址操作符函数
一、构造函数
我们之前定义过一个日期类:
class Date{
public:
void SetDate(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Display()
{
cout <<_year<< "-" <<_month << "-"<< _day <<endl;
}
private:
int _year;
int _month;
int _day;
};
}
int main()
{
Date d1,d2;
d1.SetDate(2018,5,1);
d1.Display();
Date d2;
d2.SetDate(2018,7,1);
d2.Display();
return 0;
}
对于这个类而言,当我们要初始化对象或者给对象设置内容时可以通过调用SetDate的公有方法给对象设置内容。但是有时候,我们可能会忘记初始化对象,又或者说,这样每次创建时都用此方法设置对象内容未免有些麻烦了。那能否在对象创建时,就将内容设置进去呢?
构造函数是一个特殊的成员函数,名字与类名相同,创建类类型对象时由编译器自动调用,保证每个成员函数都有一个合适的初始值,并且在对象的生命周期内只调用一次。
构造函数特点:
- 函数名与类名相同
- 无返回值(要注意不是空返回值)
- 对象实例化时编译器自动调用对应的构造函数
- 构造函数可以重载,例如:
class Date
{
public:
//1.无参构造函数
Date()
{}
//2.带参构造函数
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
void TestDate()
{
Date d1;
Date d2(2022, 4, 7);
}
注意:调用无参构造函数时不用加上(),否则就成了一个函数声明。
- 如果类中没有显示的定义构造函数,则C++编译器会自动生成一个无参的默认构造函数,一旦用户显示定义了,编译器就不再生成。
- 无参构造函数和全缺省的构造函数都称为默认构造函数,并且默认构造函数只能有一个。
class Date
{
public:
1.无参构造函数
//Date()
//{}
//2.带参构造函数
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
void TestDate()
{
Date d1;
Date d2(2022, 4, 7);
}
这里Date d1就会出问题,因为没有默认构造函数!
class Date
{
public:
1.无参构造函数
Date()
{}
//2.带参构造函数
Date(int year = 2000, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
void PrintDate()
{
cout << _year << '-' << _month << '-' << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
而上面代码也有问题。因为有多个默认构造函数。
注意:无参构造函数,全缺省的构造函数和我们没写编译器自动生成的构造函数,都是默认成员函数。
既然编译器会给默认构造函数,那我们是不是就可以不用写了呢?
class Date
{
public:
1.无参构造函数
//Date()
//{}
//2.带参构造函数
//Date(int year = 2000, int month = 1, int day = 1)
//{
// _year = year;
// _month = month;
// _day = day;
//}
void PrintDate()
{
cout << _year << '-' << _month << '-' << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
void TestDate()
{
Date d1;
d1.PrintDate();
}
这里我们没有写默认构造函数,编译器会自动生成默认构造函数,来让我看看一下结果:
好像全部都是随机值啊,编译器貌似什么也没做呀!
其实,C++把类型分为内置类型(基本类型)和自定义类型。内置类型就是语法已经定义好的类型,如:int、char、double等,自定义类型就是我们使用class、struct、union等自己定义的类型,而对于自定义类型,编译器就会调用其默认构造函数。
class Date
{
public:
1.无参构造函数
//Date()
//{}
//2.带参构造函数
Date(int year = 2000, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
void PrintDate()
{
cout << _year << '-' << _month << '-' << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
class Time
{
public:
//Time()
//{
// cout << "Time()" << endl;
// _hour = 0;
// _minute = 0;
// _second = 0;
//}
void PrintTime()
{
cout << _hour << ':' << _minute << ':' << _second << endl;
d.PrintDate();
}
private:
int _hour;
int _minute;
int _second;
Date d;
};
void TestDate()
{
Time t;
t.PrintTime();
}
结果如下:
二、析构函数
析构函数与构造函数功能相反,析构函数并不是完成对象的销毁,对象销毁工作由编译器完成,而对象在销毁时会自动调用析构函数,完成类的一些资源清理工作。
析构函数的特征:
- 析构函数名是在类名之前加上字符~。
- 无参数,无返回值。
- 一个类有且只有一个析构函数,若未显示定义,系统会自动生成默认的析构函数。
- 对象生命周期结束时,C++编译系统自动调用析构函数。
代码如下:
#include<assert.h>
typedef int DataType;
class SeqList
{
public:
SeqList(int capacity = 10)
{
_pData = (DataType*)malloc(sizeof(DataType) * capacity);
assert(_pData);
_capacity = capacity;
_size = 0;
}
~SeqList()
{
if (_pData)
{
free(_pData);
_pData = NULL;
_size = 0;
_capacity = 0;
}
}
private:
int* _pData;
int _size;
int _capacity;
};
在SeqList对象生命周期结束时,编译器就会自动的调用~SeqList这个析构函数。
和构造函数类似,对于自定义类型,编译器会自动调用其析构函数。
三、拷贝构造函数
对于内置类型,我们可以用相同类型的变量来为其初始化。那么对于自定义类型,能否这样做呢?答案是可以的:
拷贝构造函数就能提供这样一种功能:只有单个形参,该形参对本类型对象的引用,一般用const修饰,在用已存在类类型对象创建新对象时由编译器自动调用。
拷贝构造函数的特征:
- 拷贝构造函数是构造函数的一种重载形式。
- 拷贝构造函数的参数只有一个且必须使用引用传参,使用传值方式会引发无穷的递归调用。
因为实参的值传递给形参就会调用拷贝构造,而拷贝构造又要传参,传参呢又要调用拷贝构造…
class Date
{
public:
Date(int year = 2000, 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;
}
void Print()
{
cout << _year << '-' << _month << '-' << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2022, 10, 1);
d1.Print();
Date d2(d1);
d2.Print();
return 0;
}
上面代码是我们自己定义的拷贝构造函数,那如果我们不显示定义。系统也会生成默认的拷贝构造函数。如下:
class Date
{
public:
Date(int year = 2000, 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;
//}
void Print()
{
cout << _year << '-' << _month << '-' << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2022, 10, 1);
d1.Print();
Date d2(d1);
d2.Print();
return 0;
}
请看结果:
好像也能完成拷贝构造。
其实系统生成的默认拷贝构造函数,按内存存储字节来完成拷贝,这种拷贝我们叫做浅拷贝,也叫值拷贝。
对于日期这样的类来说,浅拷贝也就是值拷贝能达到我们的目标。但是对于另一些类来说,浅拷贝就会出错。比如:
lass String
{
public:
String(const char* str = "jack")
{
_str = (char*)malloc(strlen(str) + 1);
strcpy(_str, str);
}
~String()
{
cout << "~String()" << endl;
free(_str);
}
private:
char* _str;
};
int main()
{
String s1("hello");
String s2(s1);
}
上述的代码使用了浅拷贝,但是s1和s2中的成员变量却指向的是同一块地址。这样,当我们调用析构函数就会对那块地址空间释放两次。而且如果我们要更改s1或s2中成员变量指向的内容时,另一个也会随之更改。
四、赋值运算符重载
C++为了增强代码的可读性引入了运算符重载,运算符重载是具有特殊函数名的函数,也具有其返回值类型,函数名字以及参数列表,其返回值类型与参数列表与普通函数类似。
赋值运算符重载函数名为:关键字operator后面接需要重载的运算符符号(中间不加空格)。
函数原型:返回值类型 operator操作符(参数列表)。
注意:不能通过连接其他符号来创建新的操作符。比如operator@
重载操作符必须有一个类类型或枚举类型的操作数。
用于内置类型的操作符。不能改变其含义。
对于.* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载。
下面是一个==的运算符重载:
代码如下:
class Date
{
public:
Date(int year = 2000, 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;
}
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;
};
int main()
{
Date d1(2022, 10, 1);
d1.Print();
Date d2(d1);
d2.Print();
cout << (d1 == d2) << endl;
return 0;
}
下面是一个赋值运算符的重载:
代码如下:
class Date
{
public:
Date(int year = 2000, 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;
}
bool operator==(const Date& d)
{
return _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;
};
int main()
{
Date d1(2022, 10, 1);
Date d2(d1);
cout << (d1 == d2) << endl;
Date d3;
d3.Print();
d3 = d1;
d3.Print();
return 0;
}
如果一个类没有显示的定义赋值运算符重载,编译器也会生成一个,完成对象按照字节序的值的拷贝。 当然,这种拷贝也属于浅拷贝。
五、const成员
const修饰的类成员函数称之为const成员函数,const修饰类成员函数,实际修饰该成员函数隐含的this指针,表明在该成员函数中不能对类的任何成员进行修改。
请看下方代码:
class Date
{
public:
void Display()
{
cout << "Display ()" << endl;
cout << "year:" << _year << endl;
cout << "month:" << _month << endl;
cout << "day:" << _day << endl << endl;
}
void Display() const
{
cout << "Display () const" << endl;
cout << "year:" << _year << endl;
cout << "month:" << _month << endl;
cout << "day:" << _day << endl << endl;
}
private:
int _year; // 年
int _month; // 月
int _day; // 日
};
void Test()
{
Date d1;
d1.Display();
const Date d2;
d2.Display();
}
这里对象d1的初始化是正常的,而d2对象的初始化就会有问题:
我是这样理解的,如果不写构造函数,让编译器自动生成的话,其实编译器对内置类型啥都没做,所以不能算作初始化。
六、取地址符重载
class Date
{
public:
Date* operator&()
{
return this;
}
const Date* operator&()const
{
return this;
}
private:
int _year; // 年
int _month; // 月
int _day; // 日
};
这两个运算符一般不需要重载,使用编译器生成的默认取地址的重载即可。只有特殊情况下,才需要重载。比如想让别人获取到指定的内容。