类的六个默认成员函数
空类中并不是什么都没有，任何一个类在我们不写的情况下，都会自动生成下面6个默认成员函数。
- 构造函数主要完成初始化工作
- 析构函数主要完成清理工作
- 拷贝构造是使用同类对象初始化创建对象
- 赋值重载主要是把一个对象赋值给另一个对象
- 取地址运算符重载
- const取地址运算符重载
构造函数
-
构造函数是特殊的成员函数，创建类类型对象时由编译器自动调用，保证每个数据成员都有一个合适的初始值，并且在对象的生命周期内只调用一次。构造函数的主要任务是初始化对象，而不是开空间创建对象。
-
特征：
1）函数名与类名相同
2）无返回值
3）对象实例化时编译器自动调用对应的构造函数
4）构造函数可以重载
5）如果类中没有显示定义构造函数，C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成
6）无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参
构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数。
3.代码测试
class Date
{
public:
//无参构造函数（缺省构造函数）
//Date()
//{}
//带参构造函数
Date(int year,int month,int day)
{
_year = year;
_month = month;
_day = day;
}
//全缺省值的构造函数(缺省构造函数)
Date(int year = 2000,int month = 4,int day = 21)
{
_year = year;
_month = month;
_day = day;
}
//半缺省值的构造函数
Date(int year, int month, int day = 21)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
void test()
{
//调用无参构造函数（缺省构造函数）
Date d1;
//调用带参构造函数
Date d2(2000,4,21);
//调用全缺省值的构造函数(缺省构造函数)
Date d3;
Date d4(2000,4,21);
Date d5(2000,4);
//调用半缺省值构造函数
Date d6(2000, 4, 21);
Date d7(2000, 4);
}
析构函数
- 析构函数与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的，而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作
- 特征：
1）析构函数名 ~类名
2）无参无返回值
3）一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的构造函数
4）对象生命周期结束时，C++编译器自动调用析构函数
5）编译器生成的默认析构函数，对会自定类型成员调用它的析构函数，即如果一个类没有涉及到资源管理时，析构函数可以不写 - 代码测试
typedef int DataType;
class Seqlist
{
public:
Seqlist(int capacity = 10)
{
_pData = (DataType*)malloc(capacity*sizeof(DataType));
assert(_pData);
_size = 0;
_capacity = capacity;
}
~Seqlist()
{
if (_pData)
{
free(_pData);
_pData = NULL;
_capacity = 0;
_size = 0;
}
}
private:
int* _pData;
size_t _size;
size_t _capacity;
};
void TestDate()
{
Date d;
}
- [上面的代码在堆上申请了空间，必须写一个析构函数用来释放资源 ]
拷贝构造函数
- 拷贝构造函数只有单个形参，该形参是对本类类型对象的引用（一般常用constant修饰），在用已存在的类类型对象创建新对象时由编译器自动调用
- 特征
1）拷贝构造函数是构造函数的一个重载形式
2）拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式，传参期间要构造临时对象，就要调用拷贝构造函数，所以会引发无穷递归调用
3）若未显示定义，系统生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝
浅拷贝后果：两个对象会使用同一份资源，在对象销毁时会导致一份资源释放多次而引起代码崩溃，所以类中涉及到资源管理时，必须显示定义拷贝构造函数，否则就会造成浅拷贝
4）如果一个类没有涉及到资源管理，则该类的拷贝构造函数可以不用显示定义，使用编译器生成的默认拷贝构造函数即可 - 代码测试
class Date
{
public:
Date(int year = 2000, int month = 4,int day=21)
{
_year = year;
_month = month;
_day = day;
}
//这里的析构函数可以不用给出，因为没有涉及到资源管理
Date(const Date &d) //一般不会用形参改变实参，所以要用const
{
_year = d._year;
_month = d._month;
_day = d._day;
}
void PrintDate()
{
cout << _year << "/" << _month << "/" << _day;
}
private:
int _year;
int _month;
int _day;
};
void TestDate()
{
Date d;
Date d1(d);//创建d1时要调用拷贝构造函数
d.PrintDate();
d1.PrintDate();
}
赋值运算符重载
- 运算符重载
C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)
注意：
1）不能通过连接其他符号来创建新的操作符：比如operator@
2）重载操作符必须有一个类类型或者枚举类型的操作数
3）用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不能改变其含义
4）作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的
操作符有一个默认的形参this，限定为第一个形参
5）.* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载。这个经常在笔试选择题中出现 - 代码测试
class Date
{
public:
Date(int year = 2000, int month = 4, int day = 21)
{
_year = year;
_month = month;
_day = day;
}
Date(const Date &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
void PrintDate()
{
cout << _year << "/" << _month << "/" << _day;
}
//重载 > ,该运算符需要两个参数，但是作为类成员函数时，只需给出一个参数即可，因为成员函数还有一个隐藏的this指针
bool operator>(const Date& d)
{
return _year > d._year ||
_year == d._year && _month > d._month ||
_year == d._year &&_month == d._month && _day > d._day;
}
private:
int _year;
int _month;
int _day;
};
int main(){
Date d1(2000, 4, 21);
Date d2(2000, 4, 22);
if (d2 > d1)
{
cout << "d2>d1" << endl;
}
else
{
cout << "d2<=d1" << endl;
}
return 0;
}
class Date
{
public:
Date(int year = 2000, int month = 4, int day = 21)
{
_year = year;
_month = month;
_day = day;
}
Date(const Date &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
void PrintDate()
{
cout << _year << "/" << _month << "/" << _day;
}
//前置++
Date& operator++()
{
_day += 1;
return *this;
}
//后置++
//因为temp是函数栈上的对象，函数运行结束后，该对象就被销毁了，因此不能按照&的方式返回
Date operator++(int) //如果参数类型相同就无法构成函数重载,编译器为了区分而加上的参数
{
Date temp(*this);
_day += 1;
return temp;
}
private:
int _year;
int _month;
int _day;
};
int main(){
Date d(2000, 4, 21);
Date r;
r = d++;//相当于 r=d.operator++(0);如果用户显示调用后置++，必须手动传递int型参数
r = ++d;
return 0;
}
- [ 类类型对象：
1.作为参数：
一般情况下传递的都是引用（因为按照引用方式传递不需要构造临时对象，传参效率高）；如果不需要通过形参改变外部实参，将参数设置成const 类类型&
2.作为返回值
如果返回的对象不随函数的结束而销毁，直接返回引用；如果返回的是函数栈上的空间，只能按照返回值的方式
]
- 赋值运算符重载
class String
{
public:
String(const char* str = "")
{
_str = (char*)malloc(sizeof(char)*(strlen(str) + 1));
strcpy(_str, str);
}
~String()
{
if (_str)
{
free(_str);
_str = NULL;
}
}
private:
char* _str;
};
void TestString()
{
String s1("hello");
String s2("world");
//s1,s2调用构造函数
s2 = s1; //会调用赋值运算符重载，该类没有显示实现赋值运算符重载，因此编译器会生成一份默认的浅拷贝
}
- [ 上述代码存在两个问题：
1.内存泄漏
2.两个对象共用同一块内存空间，在释放对象时会导致同一份空间被释放两次而引起代码崩溃
由此可知：类中涉及到资源管理时，赋值运算符重载必须显示实现
]
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;
}
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 ;
};
- [赋值运算符主要有四点：
1）参数类型:const 类类型&
2）返回值：一定要有，否则不能支持连续赋值（d3=d2=d1 先把d1赋值给d2，再将d2赋值给d3)
3）检测是否自己给自己赋值
4）返回*this：从语法上讲，返回d也可以，但是不符合连续赋值的规则，即返回d时是先用d1给d2赋值，d1再给d3赋值
5）一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。
]
取地址及const取地址操作符重载
这两个默认成员函数一般不用重新定义 ，编译器默认会生成
扫一扫
2587
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
