目录
一、类的6个默认成员函数
在C++中,任何类中都有6个默认成员函数,如果程序员没有实现,编译器便会自动生成。即使是空类,也同样有这样的六个函数。
6个默认成员函数如下:
二、构造函数
1.概念
如下我们写一个日期类:
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 d1;
//通过Init函数来实现初始化
d1.Init(2022, 7, 5);
d1.Print();
Date d2;
d2.Init(2022, 7, 6);
d2.Print();
return 0;
}
但是如果每个类的构造都要调用初始化函数,不免过于的繁琐,所以C++就引入了构造函数来实现类对象的初始化。
构造函数:构造函数是一个特殊的成员函数, 名字与类名相同 ,创建类类型对象时由编译器 自动调用 ,以保证每个数据成员都有 一个合适的初始值,并且 在对象整个生命周期内只调用一次 。
2.特性
构造函数是特殊的成员函数,需要注意的是,构造函数虽然名称叫构造,但是构造函数的主要任务 并不是开空间创建对象,而是初始化对象 。
特征:
函数名与类名相同。 无返回值。 对象实例化时编译器自动调用对应的构造函数 构造函数可以重载。- 如果类中没有显式定义构造函数,则C++编译器会自动生成一个无参的默认构造函数,一旦用户显式定义编译器将不再生成
- 无参的构造函数和全缺省的构造函数都称为默认构造函数,并且默认构造函数只能有一个。注意:无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数,都可以认为是默认成员函数。
- 解释特性3:对象实例化时编译器自动调用对应的构造函数
可见在d1实例化完成之后,类中的成员变量已经完成初始化,因为在实例化的同时调用了构造函数。
- 解释特性4:构造函数支持重载
如下的两个Date构造函数构成函数重载
class Date
{
public:
//无参的默认成员函数
Date()
{
_year = 1;
_month = 1;
_day = 1;
}
//有三个参数的成员函数
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
初始化之后两个对象成员变量的值如下,很明显两个对象调用了不同的构造函数:
- 注意:没有参数时我在调用的时候不能加上括号(),切忌!!构造函数尤为特殊,报错如下:
- 构造函数建议写成全缺省的形式,这样他同样也是默认成员函数。代码如下:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
- 解释特性5:如果类中没有显式定义构造函数,则C++编译器会自动生成一个无参的默认构造函数,一旦用户显式定义编译器将不再生成
看如下代码把构造函数屏蔽后,类的成员变量没有初始值,和上述的特性5不匹配,要知晓原因,要知道如下性质。
C++把变量分为两种类型:
- 内置类型/基本类型:int、char、double、指针……
- 自定义类型:class、struct去定义的类型对象
C++默认生成的构造函数对内置类型不做处理,对自定义类型才会进行处理,由于之前的年、月、日均为内置类型,所以虽然会自动生成构造函数但是不会对这些int这样的内置类型进行处理,这就是为什么得到的结果为随机值。
如果是自定义类型,自动生成的构造函数会自动去调用这个自定义类型的构造函数。下文进行代码讲解:
首先:定义一个名为A的类,它有成员变量_a,他的构造函数会把_a初始化为0。
class A
{
public:
A()
{
cout << "A()" << endl;
_a = 0;
}
private:
int _a;
};
然后:定义一个Date类,成员变量中包含了类A。Date类中没有A类的构造函数。
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
A _aa;
};
int main()
{
Date d;
d.Print();
}
运行结果:
由屏幕上的结果可知,Date的构造函数中虽然只初始化了内置类型,但是自定义类型的成员变量调用了它的析构函数A()从而完成了初始化_aa的值为0。所以,构造函数实现完成的类,在其他类中被使用时,编译器会自动调用他的构造函数,无需自己重新实现构造函数。
总结:
- 如果一个类中的成员全是自定义类型,我们就可以用默认生成的函数。
- 如果有内置类型的成员,或者需要显示传参初始化,那么都要自己实现构造函数。
由于后期的程序员认为C++中对内置类型不做处理不合理,所以在C++11中打了补丁:给缺省值
没有实现构造函数,但是内置类型完成了初始化。
三、析构函数
1.概念
析构函数:与构造函数功能相反,析构函数不是完成对对象本身的销毁,局部对象销毁工作是由编译器完成的。而 对象在销毁时会自动调用析构函数,完成 对象中资源的清理工作 。
2.特性
特征:
- 析构函数名是在类名前加上字符 ~
- 无参数无返回值类型
一个类只能有一个析构函数。若未显式定义,系统会自动生成默认的析构函数。注意: 析构函数不能重载- 对象生命周期结束时,C++编译系统系统自动调用析构函数
- 编译器生成的默认析构函数,对自定类型成员调用它的析构函数
如果类中 没有申请资源时,析构函数可以不写 ,直接使用编译器生成的默认析构函数,比如Date类; 有资源申请时,一定要写 ,否则会造成资源泄漏,比如Stack类
像Date这样的日期类,并不需要使用析构函数,因为成员变量只有内置变量int类型year、month、date,无需清理对象资源,程序会自动完成类的销毁。但是像Stack一样的类,由于用到了malloc函数在堆上申请了空间,所以一定要清理对象资源。
- 总结:只有用到了malloc、new、fopen这些函数时才需要自己写析构函数
看如下代码,问类的析构顺序:
int main()
{
Stack st1;
Stack st2;
}
这里涉及到了一个知识点,由于类定义栈上,所以遵循后进先出原则,由于st1比st2优先构造,所以st2比st1优先析构。
四、拷贝构造
1.概念
通过已有的类对象来初始化另一个对象就是拷贝构造。
拷贝构造函数: 只有单个形参 ,该形参是对 本类类型对象的引用 (一般常用const修饰),在用 已存在的类类型对象创建新对象时由编译器自动调用 。
如下就是拷贝构造函数:
Date(Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
如下就是拷贝构造的实用场景:
int main()
{
Date d1(2022, 5, 18);
Date d2(d1); //拷贝构造
return 0;
}
2.特性
特性:
拷贝构造函数是 构造函数的一个重载形式 。 拷贝构造函数的 参数只有一个 且 必须是类类型对象的引用 ,使用传值方式编译器直接报错,因为 会引发无穷递归调用 。 若未显式定义,编译器 会生成默认的拷贝构造函数 。 默认的拷贝构造函数对象 按内存存储按字节序完成拷贝 ,这种拷贝叫做 浅拷贝 ,或者 值拷贝 。
- 解释特性2:拷贝构造函数的参数只有一个且必须使用引用传参,使用传值方式会引发无穷递归调用。
要像弄明白为什么要使用拷贝构造,知道一个知识点,在一个类对象赋值或者传递给另一个类对象是,编译器会自动默认的去调用他的拷贝构造。
假如拷贝构造传值而不是传引用是如下代码:
//传值
Date(Date d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
在拷贝拷贝构造被使用时首先要把类的值传给形参d,传值就要调用拷贝构造,调用拷贝构造又要传值,如此循环,就造成了死递归。如下图:
为了避免出现无限递归调用拷贝构造,所以要加上引用,加上引用后,d就是d1的别名,不存在拷贝构造了。同类型的传值传参是要调用拷贝构造的。正确代码如下:
Date(const Date& d) {}
//最好加上const,对d形成保护
- 解释特性3:若未显示定义,系统生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝,这种拷贝我们叫做浅拷贝,或者值拷贝。
如下代码没有定义拷贝构造函数,但是实现了拷贝构造的功能。这就是因为编译器自动实现了拷贝构造,把d1对象的值浅拷贝给了d2。
但是需要注意的是,编译器自主实现的拷贝构造只能完成浅拷贝,无法完成深拷贝。可见,内置类型的拷贝构造可以通过编译器自动生成的拷贝构造函数实现,但是如果换成成员变量是自定义类型呢?
class Stack
{
public:
//构造函数
Stack(int capacity = 10)
{
_a = (int*)malloc(sizeof(int) * capacity);
assert(_a);
_top = 0;
_capacity = capacity;
}
//不写拷贝构造,编译器调用默认拷贝构造
/*
Stack(const Stack& st)
{
_a = st._a;
_top = st._top;
_capacity = st._capacity;
}
*/
//析构函数
~Stack()
{
cout << "~Stack():" << this << endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
int* _a;
int _top;
int _capacity;
};
int main()
{
Stack st1(10);
Stack st2(st1);
}
在调试是,这段代码会发生如下报错:
其原因就是编译器默认生成的拷贝构造函数对st2完成了st1的浅拷贝,导致两者的地址是完全相同的,由编译器调试可见下图:
内存结构如下图,st1和st2的两个指针指向同个地址:
这是两个对象分别调用析构函数,把一个地址释放了两次,自然会发生报错,所以,我们遇到自定义类型时要自己完成拷贝构造函数,给它开辟新的空间,在把数据搬运到这个空间中,实现深拷贝。
- 总结:一般的类,自己生成拷贝构造就够用了,只有像Stack这样自己直接管理资源的类,需要自己实现深拷贝。
注:如下代码是拷贝构造而不是赋值
void TestDate2()
{
Date d1(2022, 5, 18);
Date d3 = d1; //等价于 Date d3(d1);
}
五、赋值运算符重载
1.运算符重载
C++为了增强代码的可读性引入了运算符重载,运算符重载是具有特殊函数名的函数,也具有其返回值类型,函数名字以及参数列表,其返回值类型与参数列表与普通的函数类似。
- 函数名字为:关键字operator后面接需要重载的运算符符号。
- 函数参数:运算符操作数
- 函数返回值:运算符运算后结果
- 函数原型:返回值类型 operator操作符(参数列表)
bool operator==(const Date& d1, const Date& d2) //避免传值传参调用拷贝构造
{
return d1._year == d2._year &&
d1._month == d2._month &&
d1._day == d2._day;
}
运行结果如下:
可见,通过运算符重载实现了“==”,但是在类外实现无法访问类内的private成员变量,所以我们需要屏蔽private,让他成为public。但是这样操作严重破坏了类的封装性,所以我们一般把运算符重载放在类内。
由于成员函数在传参是有一个隐藏指针this,这个this指针就是传的操作符用到的第一个操作数,所以和定义在类外相比,要减少一个参数。代码如下:
bool operator==(const Date& d)//编译器会处理成 bool operator(Date* const this, const Date& d)
{
return _year == d._year &&
_month == d._month &&
_day == d._day;
}
显示调用如下:
d1.operator==(d2)
但一般直接写成这样:
d1==d2
运算符重载注意点:
不能通过连接其他符号来创建新的操作符:比如operator@ 重载操作符必须有一个类类型参 用于内置类型的运算符,其含义不能改变,例如:内置的整型+,不 能改变其含义 作为类成员函数重载时,其形参看起来比操作数数目少1,因为成员函数的第一个参数为隐藏的this .* :: sizeof ?: . 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。
2.赋值运算符重载
有了运算符重载的知识,我们能很轻松的写出赋值运算符重载的函数:
//d2 = d1; -> d2.operator=(&d2, d1);
void operator=(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
但是需要注意的是,赋值符号可以连续赋值,为了实现类似的效果,我们要加上返回值this*。代码如下:
Date operator=(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
return *this;
}
此外,这个函数还可以进行如下两点的修改:
- 刚才我们写的赋值重载是传值返回,传值返回会生成一个拷贝,会调用拷贝构造。由于出了作用域对象还存在,所以我们就可以用传引用返回
- 有可能会存在这样的情况:d1=d1,像这样自己给自己赋值的情况还要再调用赋值重载函数属实没必要,所以我们还可以加个if条件判断。
//d2 = d1; -> d2.operator=(&d2, d1);
Date& operator=(const Date& d)
{
if (this != &d) //不推荐写成if (*this != d) ,怕的是万一没有重载!=呢?,因为这里是对象的比较
{
_year = d._year;
_month = d._month;
_day = d._day;
}
return *this;
}
- 赋值运算符重载注意:就算程序员不实现赋值运算符重载,编译器也会自动生成,但是要拷贝构造相同,只能完成浅拷贝,涉及深拷贝要自行实现。
七、const成员
概念:将 const修饰的“成员函数”称之为const成员函数 , const 修饰类成员函数, 实际修饰该成员函数隐含的this指针 ,表明在该成员函数中不能对类的任何成员进行修改。
如下代码存在报错:
其原因是代码在Func中的形参由于被const所修饰,所以this指针的类型变为了const *A,所以,权限被缩小了,而调用类中print函数时会传递this指针,类中的this指针的类型为*A,这就形成了典型的权限放大问题。
我们通过上文的const来修饰成员函数就能解决这个问题。正确代码如下:
class A
{
public:
// const 修饰 *this
// this的类型变成 const A*
// 内部不改变成员变量的成员函数
// 最好加上const,const对象和普通对象都可以调用
void Print() const
{
cout << _a << endl;
}
void Add(int x)
{
_a += x;
}
private:
int _a = 10;
};
void Func(const A& x)
{
x.Print();
cout << &x << endl;
}
int main()
{
A aa;
aa.Print();
Func(aa);
return 0;
}