👑作者主页:@安 度 因
🏠学习社区:StackFrame
📖专栏链接:C++修炼之路
文章目录
- 一、再谈构造函数
- 1、初始化列表
- 2、explicit 关键字
- 二、static 成员
- 1、概念
- 2、特性
- 三、友元
- 1、友元函数
- 2、友元类
- 四、内部类
- 五、匿名对象
- 六、构造(拷贝构造)对象时的一些编译器优化
- 七、再谈类和对象
如果无聊的话,就来逛逛 我的博客栈 吧! 🌹
一、再谈构造函数
1、初始化列表
初始化列表:对于 构造函数(构造与拷贝构造) 来说,以一个冒号开始,接着一个以逗号分隔的数据成员列表,每个"成员变量"后面跟一个放在括号中的初始值或表达式,每个成员变量只能初始化一次,对于变量来说可以初始化也可以不初始化
Date d1(2023, 2, 5); // 对象整体定义的地方
初始化列表:对象的成员定义的地方
例如:
当然 _year 的括号内也可以为 -year
,甚至是常量,都可以。初始化时,就会根据初始化列表的表达式内容进行初始化。
类中包含以下成员,必须放在初始化列表位置进行初始化 :
- const 成员变量
- 引用成员变量
- 没有默认构造函数的自定义类型成员变量(对象必须初始化,如果没有默认构造的成员变量无法构造就要报错)
因为对于 const 修饰的变量来说,必须在定义时初始化 ,否则后面不可改,引用也是一个道理;而对于没有默认构造函数的自定义类型,由于无法自动调用它的默认构造函数,所以也需要在定义时初始化。
对于:
class A
{
private:
int _year;
int _month;
int _day;
const int _N;
int& _ref;
A _aa;
};
int main()
{
A aa; // 对整个对象进行定义
}
对于类中的成员,它们只是成员变量的声明 ,不能在这里初始化;而定义则是在主函数中对对象整体进行定义并不是成员定义的地方 ,当在构造函数中,对 _N 进行初始化时报错了,因为此刻 _N 已经被定义,此刻是在函数体中,无法再对其进行初始化 :
而使用初始化列表就可以,因为初始化列表是成员变量定义的地方 ,无论是对于引用,const 成员变量,又或者是无构造函数的自定义类型成员(自动调用非默认构造函数),都可以完成初始化:
class A
{
public:
A(int a){ _a = a; } // 非默认构造函数
private:
int _a;
};
class Date
{
public:
Date(int year, int month, int day, int i)
:_N(10)
,_ref(i)
,_aa(-1)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
const int _N;
int& _ref;
A _aa;
};
int main()
{
Date d1(2023, 2, 6, 10);
return 0;
}
尽量使用初始化列表初始化,因为不管你是否使用初始化列表,对于自定义类型成员变量,一定会先使用初始化列表初始化。
类 A:
class A
{
public:
A(int a = 1)
{
cout << "进行构造" << endl;
_a = a;
}
A(const A& a)
{
cout << "进行拷贝构造" << endl;
_a = a._a;
}
A& operator=(const A& a)
{
cout << "赋值重载" << endl;
_a = a._a;
return *this;
}
private:
int _a;
};
看如下动图:
虽然我们没有写初始化列表,但是初始化列表是成员变量定义的地方,所以 _aa 会在初始化列表定义的时候默认调用其构造函数。
所以适当时刻使用初始化列表可以效率提升,因为此刻,只发生一次拷贝构造(存在成员初始化不存在成员) :
所以,建议自定义类型的成员,在初始化列表进行初始化,更加高效 。
C++11 中的补丁,提供了给成员变量缺省值的方式,若没有显示写缺省值的处理,含缺省值的变量都会在初始化列表进行初始化 ;若显示写初识化列表了,就使用初始化列表的。本质上还是使用初始化列表进行初始化,因为初始化列表是成员定义的时候。
总结:
- 哪个对象调用构造函数,初始化列表是它所有成员变量定义的位置
- 不管是否显示在初始化列表写,那么编译器每个变量都会初始化列表定义初始化
反正记住一句话:优先使用初始化列表初始化。
考察 :
class A
{
public:
A(int a)
:_a1(a)
, _a2(_a1)
{}
void Print()
{
cout << _a1 << " " << _a2 << endl;
}
private:
int _a2;
int _a1;
};
int main()
{
A aa(1);
aa.Print();
}
选项:
- A. 输出1 1
- B.程序崩溃
- C.编译不通过
- D.输出1 随机值
因为成员变量在类中声明次序就是其在初始化列表中的初始化顺序,与其在初始化列表中的先后次序无关 。
_a2 先声明,所以初始化列表先初始化,此刻 _a1 为随机值,将随机值给 _a2 ,再初始化 _a1,将 a 的值初始化为 1 。
所以,建议将声明次序和初始化列表次序对应,防止混淆。
2、explicit 关键字
隐式类型转换:
Date d2 = 2022 时发生了隐式类型转换(意义相似类型转换)。由于支持单参数的构造函数,所以这里用 2022 构造一个临时对象 Date tmp(2022),再用这个对象拷贝构造给 d2 ,但是 C++ 编译器在连续构造的过程中,多个构造会被优化,合二为一,变为一个构造:
d1 一次构造,d2 一次构造,一次拷贝构造合并为一次构造。 如果不想要实现隐式类型转换,就可以加上 explicit 关键字修饰 :
这时,就不会进行转换了。
对于单参数的构造函数,可以支持应试类型转换。对于多参数的构造函数,需要这么写:
class A
{
public:
A(int a)
:_a1(a)
{
cout << "A(int)" << endl;
}
// explicit A(int a1, int a2) 如果不想要隐式转换,则加 explicit 修饰
A(int a1, int a2)
:_a1(a1)
, _a2(a2)
{}
A(const A& aa)
:_a1(aa._a1)
{
cout << "A(const A& aa)" << endl;
}
private:
int _a2;
int _a1;
};
int main()
{
A a3 = { 2, 2 }; // 多参数隐式类型转换
return 0;
}
对于 explicit 修饰的构造函数称为显示构造函数,对于没有用 explicit 修饰的构造函数称为隐式构造函数。
二、static 成员
1、概念
声明为static的类成员称为类的静态成员,用static修饰的成员变量,称之为静态成员变量;用static修饰的成员函数,称之为静态成员函数。静态成员变量一定要在类外进行初始化
考题1:
如何使用程序计算一个对象被构造了几次?
但是对于全局变量,可以随之改变:
cnt++;
所以并不好,如何让 cnt 和 A 绑定起来,并且始终只有一个?static 成员,它属于整个类,所有对象,生命周期在整个程序运行期间 。static 成员在类的所有对象中都可以使用,它并不在对象中,而是在类中,所有类对象只有一个staic 成员。
访问 :
若 static 成员为 public :
静态成员变量可以用对象和类访问。
private:
(statoc 修饰的成员函数没有 this 指针,所以在里面不能访问 _a )
但是指定类域(.)和使用类作用限定符(::)就可以访问。
static 成员在类外面定义(特例,仅限于静态,因为不能在某个构造函数定义,它属于类,不单独属于对象)。
写一个 GetCnt 函数,来获取 _sCnt 。静态成员函数可以用对象和类访问,即 a1.GetCnt() ,A::Getcnt() 。
考题2:
class Sum
{
public:
Sum()
{
_ret += _i;
++_i;
}
static int GetRet() // 静态成员函数
{
return _ret;
}
private:
static int _i;
static int _ret;
};
int Sum::_i = 1;
int Sum::_ret = 0;
class Solution {
public:
int Sum_Solution(int n) {
Sum a[n]; // 构造 n 次
// return Sum().GetRet() - (n + 1); // 匿名对象多构造一次
// return a[0].GetRet();
return Sum::GetRet();
}
};
使用静态成员变量,_i
初始化为 1, _ret
初始化为 0 ,两者在全局初始化。对 Sum 类的构造函数每次将 ret 累加,并且让 _i 自增,这样构造 n 次,就可以计算出从 1 + … n . 再写一个静态成员函数,返回 _ret ,这些为计算过程。
可以 Sum().GetRet() 使用匿名对象返回,所以需要 Sum().GetRet() - (n + 1)
;最好的返回方式还是用类来访问静态成员函数 Sum::GetRet()
,还有很多种返回方式,看注释。
在 C++11 中,提供了成员变量的缺省值:
但是虽然将 _a 给为 0 ,但是说 int _a = 0 是初始化并不对,因为在 A 类中,只是完成了对成员变量的声明。缺省值只是在未明确初始化时,在该成员变量在初始化时,才会默认使用这个缺省值。
如果在初始化列表阶段,没有对成员变量初始化,就会使用缺省值初始化 :
甚至,在成员变量中,给为 int* p = (int*)malloc(4 * 10)
都是可以的,但是记住这里是缺省值。
但是对于静态成员变量是不可以这样给缺省值的,必须在类外面全局位置定义初始化 :
使一个对象只能在栈上创建/堆上创建:
#include <iostream>
using namespace std;
class A
{
public:
static A GetStackObj()
{
A aa;
return aa;
}
static A* GetHeapObj()
{
return new A;
}
// 封装成私有,只能在类内部调用
// 这样子就不能直接创建对象
private:
A()
{}
private:
int _a1 = 1;
int _a2 = 2;
};
int main()
{
// 但是调用两个成员函数就会被对象和成员函数的优先级所困扰
// 因为调用需要有一个对象,但是对象的指定创建范围不同
// 这时就可以使用静态成员函数
// static A GetStackObj();
return 0;
}
2、特性
- 静态成员为所有类对象所共享,不属于某个具体的对象,存放在静态区
- 静态成员变量必须在类外定义,定义时不添加static关键字,类中只是声明
- 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
- 静态成员函数没有隐藏的this指针,不能访问任何非静态成员
- 静态成员也是类的成员,受public、protected、private 访问限定符的限制
- 静态变量成员不可以给缺省值,得在全局定义
- 非静态能调用静态,静态不能调用非静态(因为调用非静态要传递 this 指针,但是 static 成员没有 this 指针)
三、友元
友元提供了一种突破封装的方式,有时提供了便利。但是友元会增加耦合度,破坏了封装,所以友元不宜多用。
友元分为:友元函数和友元类
友元就像黄牛一样,破坏管理规则,能不用就不用。
1、友元函数
我们有没有思考过一个问题:既然运算符可以重载,那么流插入与流提取操作符 << 和 >> 是否可以重载呢?
能否将对象像内置类型一样输入和打印?就像这样?
可以!C++ 允许重载这两个操作符,就拿 << 来说:
对于流插入操作符来说,有两个参数 cout
和 d1
,cout
的类型为 ostream:
ostream 本身是一个类对象,并且 << 能自动匹配类型的原因是因为运算符重载过了,而对于自定义类型并没有重载。可以理解为 << 已经进行过了函数重载 + 运算符重载。
我们试着在类中写一下:
void Date::operator<<(ostream& out)
{
out << _year << '-' << _month << '-' << _day << endl;
}
形参 out 为 cout 的别名,通过这种方式,在主函数中调用:
发现是无法调用的,但是如果我们主动调用 :
这是因为在运算符重载中,对于双操作数的操作符重载,第一个参数是操作数,第二个参数是右操作数。
而我们上方的写法让 cout 变为了第二个操作数,就相当于变成了 d1 << cout
,错乱了:
但是这很明显不符合我们的习惯。而 this 指针已经占用了第一个参数,左操作数一定是对象,所以如果写重载的话一定实现不,就不能写作成员函数。
所以就写在类外面,写作全局的不就好了,这样就不受类的特性的约束了 :
但是这里又迎来一个问题:访问不到类中的成员变量 ,对于这个问题,我们也遇到过,要么是将类成员变量私有权限放开;要么是给一个调取数据的函数,但是这样虽然可以解决调取数据的问题,可是对于 >> 流提取函数的实现又成了一个问题:无法获取到输入数据,而使用这种方案解决了也很麻烦,所以这两种方案都被排除了。
那么有没有什么简便的方法?一个全局函数想用对象访问类中私有或保护的成员,可以使用友元。意思就是让类的“朋友”访问到它的私有对象。
友元函数的声明需要写在类里面:
此刻就可以访问了:
但是这里不能连续输出 ,和之前讲过的连续赋值的原因是相同的,因为 cout << d1 << d2; 由于函数没有返回值,并不能起到连续输出的效果。所以可以稍加改进,让每次输出后,都可以获取 cout :
这时,就可以连续输出了:
同理,对于 >> 的函数,我们也可以写出来:
istream& operator>>(istream& in, Date& d) // d 要被修改,不能加 const
{
in >> d._year >> d._month >> d._day;
return in;
}
总结 :
- 友元函数可访问类的私有和保护成员,但不是类的成员函数
- 友元函数 不能用const修饰
- 友元函数可以在 类定义的任何地方声明,不受类访问限定符限制
- 一个函数可以是多个类的友元函数
- 友元函数的调用与普通函数的调用原理相同
2、友元类
友元类的所有成员函数都变为是另一个类的友元函数,都可以访问另一个类中的非公有成员 。
- 友元关系是单向的,不具有交换性
class Time
{
// 日期类想要经常访问 Time ,让 Date 变为 Time 的友元类
friend class Date; // 声明日期类为时间类的友元类,则在日期类中就直接访问Time类中的私有成员变量
public:
Time(int hour = 0, int minute = 0, int second = 0)
: _hour(hour)
, _minute(minute)
, _second(second)
{}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{}
void SetTimeOfDate(int hour, int minute, int second)
{
// 直接访问时间类私有的成员变量
_t._hour = hour;
_t._minute = minute;
_t._second = second;
}
private:
int _year;
int _month;
int _day;
Time _t;
};
比如上述Time类和Date类,在Time类中声明Date类为其友元类,Date 类为 Time 类的友元。那么可以在Date类中直接访问Time类的私有成员变量 ,但想在Time类中访问Date类中私有的成员变量则不行。
但是 Time 类不能访问 Date 类 。举个中二的例子,就好比说,Date 类是主,Time 类是仆,Date 类和 Time 类缔结了神魂契约,对于 Date 类来说,可以随时查看 Time 的情况,但是对于 Time 并不能随时查看 Date 的情况;除非它俩关系对等,签订平等的契约才可以(在 Date 类中,声明 Time 类为其友元类)
class Time
{
// 日期类想要经常访问 Time ,让 Date 变为 Time 的友元类
friend class Date; // 声明日期类为时间类的友元类,则在日期类中就直接访问Time类中的私有成员变量
public:
Time(int hour = 0, int minute = 0, int second = 0)
: _hour(hour)
, _minute(minute)
, _second(second)
{}
void Func(Date d);
private:
int _hour;
int _minute;
int _second;
};
class Date
{
friend class Time;
public:
Date(int year = 1900, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{}
void SetTimeOfDate(int hour, int minute, int second)
{
// 直接访问时间类私有的成员变量
_t._hour = hour;
_t._minute = minute;
_t._second = second;
}
private:
int _year;
int _month;
int _day;
Time _t;
};
void Time::Func(Date d) // Date 和 Time 两者互为友元,所以 Time 中现在可以访问 Date
{
cout << d._year << endl;
}
int main()
{
return 0;
}
友元类和友元函数一样,不受访问限定符的约束:
如图在 A 类中,将友元类 C 的声明放为私有(其实平时放在 class 中也就是私有,这里只是为了说明),此刻 C 能访问 A ,在主函数创建对象时,A 也通过构造完成初始化,调用 c1 的成员函数也访问到了 A 的成员。
友元关系不能传递
如果C是B的友元, B是A的友元,则不能说明C时A的友元。友元关系不能继承,在继承位置再详细介绍。
四、内部类
概念:如果一个类定义在另一个类的内部,这个类就叫做内部类。内部类是一个独立的类,它不属于外部类,更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
注意:内部类就是外部类的友元类,参见友元类的定义,内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
对外部类大小的计算,和内部类中的成员变量没有关系,因为里面并没有包含对象,只是图纸而已:
再看一个例子:
class A
{
private:
static int k;
int h;
public:
class B // B天生就是A的友元
{
public:
void foo(const A& a)
{
cout << k << endl; // ok,内部类可以访问外部类的私有
cout << a.h << endl; // ok
}
private:
int _b;
};
void f(B b)
{
// cout << b._b << endl; // err ,外部类不能访问内部类的私有
}
};
int A::k = 1;
int main()
{
A::B b; // 内部类的定义
return 0;
}
内部类 B 和在全局定义时基本一样的,但是外部类 A 类域限制定义在 A 的类域中,就比如定义内部类对象时,需要指定外部类的类域:A::B b
内部类 B 天生就是外部类 A 的友元,也就是 B 中可以访问 A 的私有,A 不能访问 B 的私有 :就比如 B 类中可以访问 A 中私有成员变量,但是 A 不能访问 B 的私有,除非将权限开放为公有。
内部类改写 JZ76
class Solution {
private:
class Sum
{
public:
Sum()
{
_ret += _i;
++_i;
}
};
private:
static int _i;
static int _ret;
public:
int Sum_Solution(int n) {
Sum a[n];
return _ret;
}
};
int Solution::_i = 1;
int Solution::_ret = 0;
将 Sum 包为内部类,并将 _i 和 _ret 变为 Solution 的成员变量,Sum 默认为 Solution 的友元,那么 Sum 可以访问这两个成员。而返回时,也不需要借助成员函数,直接返回成员变量即可。
优点:根据内部类的特性,将成员变量放到 Solution 后,根据两者的特性,就可以访问到 _ret ,这时不再需要使用成员函数获取 _ret
五、匿名对象
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
class Solution {
public:
int Sum_Solution(int n) {
//...
return n;
}
};
int main()
{
A aa1;
// A aa1();
// 不能这么定义对象,因为编译器无法识别下面是一个函数声明,还是对象定义
// 但是我们可以这么定义匿名对象,匿名对象的特点不用取名字,
// 但是他的生命周期只有这一行,我们可以看到下一行他就会自动调用析构函数
A();
A aa2(2);
// 匿名对象在这样场景下就很好用,当然还有一些其他使用场景,这个我们以后遇到了再说
Solution().Sum_Solution(10);
return 0;
}
六、构造(拷贝构造)对象时的一些编译器优化
在同一句语句中,不存在的对象或者有多个构造或拷贝构造,这些构造过程可能会合二(三)为一。
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
A(const A& aa)
:_a(aa._a)
{
cout << "A(const A& aa)" << endl;
}
A& operator=(const A& aa)
{
cout << "A& operator=(const A& aa)" << endl;
if (this != &aa)
{
_a = aa._a;
}
return *this;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
void f1(A aa)
{}
A f2()
{
A aa;
return aa;
}
int main()
{
// 传值传参
A aa1;
f1(aa1);
cout << endl;
// 传值返回
f2();
cout << endl;
// 隐式类型,连续构造+拷贝构造->优化为直接构造
f1(1);
// 一个表达式中,连续构造+拷贝构造->优化为一个构造
f1(A(2));
cout << endl;
// 一个表达式中,连续拷贝构造+拷贝构造->优化一个拷贝构造
A aa2 = f2();
cout << endl;
// 一个表达式中,连续拷贝构造+赋值重载->无法优化
aa1 = f2();
cout << endl;
return 0;
}
七、再谈类和对象
现实生活中的实体计算机并不认识,计算机只认识二进制格式的数据。如果想要让计算机认识现实生活中的实体,用户必须通过某种面向对象的语言,对实体进行描述,然后通过编写程序,创建对象后计算机才可以认识。比如想要让计算机认识洗衣机,就需要:
用户先要对现实中洗衣机实体进行抽象—即在人为思想层面对洗衣机进行认识,洗衣机有什么属性,有那些功能,即对洗衣机进行抽象认知的一个过程
经过1之后,在人的头脑中已经对洗衣机有了一个清醒的认识,只不过此时计算机还不清楚,想要让计算机识别人想象中的洗衣机,就需要人通过某种面相对象的语言(比如:C++、Java、Python等)将洗衣机用类来进行描述,并输入到计算机中
经过2之后,在计算机中就有了一个洗衣机类,但是洗衣机类只是站在计算机的角度对洗衣机对象进行描述的,通过洗衣机类,可以实例化出一个个具体的洗衣机对象,此时计算机才能洗衣机是什么东西。
用户就可以借助计算机中洗衣机对象,来模拟现实中的洗衣机实体了。
在类和对象阶段,大家一定要体会到,类是对某一类实体(对象)来进行描述的,描述该对象具有那些属性,那些方法,描述完成后就形成了一种新的自定义类型,才用该自定义类型就可以实例化具体的对象 。