类与对象(二)
类的6个默认成员函数
如果一个类中什么成员都没有,简称为空类。
空类中真的什么都没有吗?并不是,任何类在什么都不写时,编译器会自动生成以下6个默认成员函数。
默认成员函数:用户没有显式实现,编译器会生成的成员函数称为默认成员函数。
构造函数
构造函数是用来初始化对象而不是构建对象。
以时间类为例,包含不同的成员变量,每使用一次,都初始化一次非常麻烦,有时还会忘记。所以可以利用构造函数自动初始化。
构造函数是一个特殊的成员函数,名字与类名相同,创建类类型对象时由编译器自动调用,以保证每个数据成员都有一个合适的初始值,并且在对象整个生命周期内只调用一次。
//时间类
class Date
{
public:
Date(int year,int month; int day)
{
//带参的构造函数
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
}
int main()
{
Date d1(2022,9,6);
}
构造函数的特性
构造函数是特殊的成员函数,需要注意的是,构造函数虽然名称叫构造,但是构造函数的主要任务并不是开空间创建对象,而是初始化对象。
其特征如下:
- 函数名与类名相同。
- 无返回值。
- 对象实例化时编译器自动调用对应的构造函数。
- 构造函数可以重载。
class Date
{
public:
//不带参的构造函数
Date()
{};
//带参的构造函数
Date(int year,int month; int day)
{
_year = year;
_month = month;
_day = day;
};
//有缺省值的构造函数
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()
{
//会自动调用带参的构造函数
Date d1(2022,3,4);
//不带参的
Date d2;
//不能加括号,不能就成了函数的声明了,变成了一个函数名为d3,函数返回值为Date的函数声明
//warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
Date d3();
}
5.如果类中没有显式定义构造函数,则C++编译器会自动生成一个无参的默认构造函数,一旦用户显式定义编译器将不再生成。
class Date
{
public:
private:
int _year;
int _month;
int _day;
}
int main()
{
//当Date类中没有写构造函数时,会调用默认的构造函数
Date d3;
//如果有显式的构造函数,将会报错,因为有显式的构造函数,编译器就不会默认生成无参的构造函数
//无参构造函数,放开后报错:error C2512: “Date”: 没有合适的默认构造函数可用
}
6.无参的构造函数和全缺省的构造函数都称为默认构造函数,并且默认构造函数只能有一个。注意:无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数,都可以认为是默认成员函数。
7. 那么关于编译器生成的默认构造函数的到底有作用?
C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语法已经定义好的类型:如int/char…,自定义类型就是我们使用class/struct/union自己定义的类型,编译器对于内置类型是不处理的,对于自定义类型则会调用他们本身的默认构造函数。
其实这样是不合理的,所以在c++11中就打了补丁:
class Date
{
public:
private:
int _year = 1;//相当于缺省值了
int _month = 1;
int _day = 1;
}
析构函数
概念:
析构函数:与构造函数功能相反,析构函数不是完成对对象本身的销毁,局部对象销毁工作是由编译器完成
的。而对象在销毁时会自动调用析构函数,完成对象中资源的清理工作。
我之前也会疑惑,为什么还需要清理呢?直到想到还有在堆上申请的空间。
特性
析构函数是特殊的成员函数,其特征如下:
- 析构函数名是在类名前加上字符 ~。
- 无参数无返回值类型。
- 一个类只能有一个析构函数。若未显式定义,系统会自动生成默认的析构函数。注意:析构函数不能重
载 - 对象生命周期结束时,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;
};
- 当没有显式的析构函数时,编译器会自动生成的默认析构函数,对自定类型成员调用它的析构函数。
- 如果类中没有申请资源时,析构函数可以不写,直接使用编译器生成的默认析构函数,比如Date类;有资源申请时,一定要写,否则会造成资源泄漏,比如Stack类。
拷贝构造函数
概念:
那在创建对象时,可否创建一个与已存在对象一某一样的新对象呢?
拷贝构造函数:只有单个形参,该形参是对本类类型对象的引用(一般常用const修饰),在用已存在的类类型对象创建新对象时由编译器自动调用。
特性:
拷贝构造函数也是特殊的成员函数,其特征如下:
- 拷贝构造函数是构造函数的一个重载形式。
- 拷贝构造函数的参数只有一个且必须是类类型对象的引用,使用传值方式编译器直接报错,因为会引发无穷递归调用。
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
// Date(const Date& d) // 正确写法
Date(const Date d) // 错误写法:编译报错,会引发无穷递归
{
_year = d._year;
_month = d._month;
_day = d._day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
Date d2(d1);
return 0;
}
为何传值调用会造成无穷递归?
如果利用传值传参时,不会传递实参本身而是他的拷贝,那么在过程中就会调用其拷贝构造函数,那可不就无线套娃了嘛。
如图:
3. 若未显式定义,编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝,这种拷贝叫做浅拷贝,或者值拷贝 。
注意:在编译器生成的默认拷贝构造函数中,内置类型是按照字节方式直接拷贝的,而自定义类型是调用其拷贝构造函数完成拷贝的。
4. 编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了,还需要自己显式实现吗?是需要的,在某些类中,值拷贝会造成程序的崩溃。
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;
};
int main()
{
Stack s1;
s1.push(1);
s1.push(2);
s1.push(3);
Stack s2(s1);
return 0;
}
//运行后,会发现程序会崩溃。why?
//简单来说就是,s2和s1的内容一模一样,s1的_arry和s2的_arry指向的是同一块位置,当我们回收s2时,会释放_arry指向的空间
//当我们回收是s1时也会释放那块空间,这时就会造成崩溃。
//为什么先释放s2?因为销毁时也遵循后进先出的原则(在栈上)
注意:类中如果没有涉及资源申请时,拷贝构造函数是否写都可以;一旦涉及到资源申请时,则拷贝构造函数是一定要写的,否则就是浅拷贝。
5. 拷贝构造函数典型调用场景:
- 使用已存在对象创建新对象
- 函数参数类型为类类型对象
- 函数返回值类型为类类型对象
为了提高程序效率,一般对象传参时,尽量使用引用类型,返回时根据实际场景,能用引用尽量使用引用。
赋值运算符重载
运算符重载
运算符包括+ 、+=、 -、-=、>、>=、<、<=等等,内置类型可以直接使用,类类型呢?
不能直接使用,所以C++引入了运算符重载,运算符重载是具有特殊函数名的函数,也具有其返回值类型,函数名字以及参数列表,其返回值类型与参数列表与普通的函数类似。
函数名字为:关键字operator后面接需要重载的运算符符号。
函数原型:返回值类型 operator操作符(参数列表)
比如:如果操作符是加号,就应该有2个操作数,int operator+(Date d,int day)。Date d-左操作数,int day-右操作数
注意:
- 不能通过连接其他符号来创建新的操作符:比如operator@
- 重载操作符必须有一个类类型参数
- 用于内置类型的运算符,其含义不能改变,例如:内置的整型+,不 能改变其含义
- 作为类成员函数重载时,其形参看起来比操作数数目少1,因为成员函数的第一个参数为隐藏的this
- .* 、::、 sizeof、 ?: 、. 注意以上5个运算符不能重载。这个经常在笔试选择题中出现
以时间类为例
//时间类
class Date
{
public:
Date(int year,int month, int day)
{
//带参的构造函数
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
//成员 "Date::_year" (已声明 所在行数:16) 不可访问
//无法访问,是类外无法访问私有成员,可以利用友元,可以直接写在类中
//
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(2022,9,6);
Date d2(d1);
cout<<(d1==d2)<<endl;
}
//时间类
class Date
{
public:
Date(int year,int month, int day)
{
//带参的构造函数
_year = year;
_month = month;
_day = day;
}
//不用写左操作数 const Date& d1,有this指针啦
bool operator==(const Date& d2)
{
return _year == d2._year
&& _month == d2._month
&& _day == d2._day;
};
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2022, 9, 6);
Date d2(d1);
cout << (d1 == d2) << endl;
return 0;
}
赋值运算符重载
class Date
{
public:
Date(int year,int month, int day)
{
//带参的构造函数
_year = year;
_month = month;
_day = day;
}
bool operator=(const Date& d2)
{
return _year = d2._year
&& _month = d2._month
&& _day = d2._day;
};
private:
int _year;
int _month;
int _day;
};
const成员函数
将const修饰的类成员函数称之为const成员函数,const修饰类成员函数,实际修饰该成员函数隐含的this指针,表明在该成员函数中不能对类的任何成员进行修改。
如以下代码:
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
void Display()
{
_year = 2002;
cout << "Display ()" << endl;
cout << "year:" << _year << endl;
cout << "month:" << _month << endl;
cout << "day:" << _day << endl << endl;
}
void Display() const//相当于 const Date* this
{
_year = 2002;//由于正在通过常量对象访问“_year”,因此无法对其进行修改
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();
}
int main()
{
Test();
return 0;
}