🍇explicit
禁止函数进行隐式转换(C98是单参数,C11就是多参数了)
话不多说,我们进行代码分析
这里证明一下为什么会有临时变量的产生
我们用引用对象就可以证明这中间一定有临时变量的产生了,因为临时变量具有常属性,而这个引用不是常属性的,所以报错了
通过上图对比发现,explicit
的存在导致构造函数的形参不能发生隐式转换从而报错。
🚀static
我们在学习c语言的时候也学过这个static,一般用来修饰变量,凡是被他修饰过的变量都会存储在运行内存的静态区里面。
现在我们学习在类里面使用的static
,在c里学习的差不多。
- 凡是被static修饰过的成员函数或者变量,被称为静态成员函数或静态成员变量,都归属与一个类里,而不是单单属于某个对象。
- 静态成员函数、变量创建的时间和类创建的时间一样,静态成员变量的定义要在类外定义。
看代码,在类内初始化会显示报错,下面的类外初始化代码才是正确的。- 静态成员函数,变量为什么只属于类呢,其原因是因为没有隐藏的this指针,所以静态成员函数调用不了非静态成员变量,如图
特例:只有
const static int 变量名 = 整形
可以类内定义。如图:
⚓inline
在 c/c++ 中,为了解决一些频繁调用的小函数大量消耗栈空间(栈内存)的问题,特别的引入了 inline
修饰符,表示为内联函数。
inline
关键字仅用于函数,不能用于变量什么其他地方。加上inline
关键字的函数称为内联函数。inline
是作为建议型的关键字,并不是说,任何函数加了inline
都成为了内联函数,建议是频繁调用的小函数作为内联函数,而如递归函数就算前面有inline
关键字修饰,编译器也不会让它成为内联函数。- 在类内定义的成员函数都是内联函数。
- 关键字
inline
必须与函数定义体放在一起才能使函数成为内联,仅将 inline 放在函数声明前面不起任何作用。
inline
的底层实现
加上
inline
关键字的函数在反汇编时不会生成函数地址,而是直接展开指令。普通函数则是通过函数地址跳转,再去执行指令。
🚨缺点:inline
会产生代码膨胀
🍉友元
友元,关键字friend
分为友元函数和友元类:
- 友元函数可以直接访问类的私有成员,它是定义在类外部的普通函数,不属于任何类,但需要在类的内部声明,声明时需要加friend关键字。
友元函数可访问类的私有和保护成员,但不是类的成员函数
友元函数不能用const修饰
友元函数可以在类定义的任何地方声明,不受类访问限定符限制
一个函数可以是多个类的友元函数
友元函数的调用与普通函数的调用原理相同
友元类没有this指针
- 友元类
友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类中的非公有成员。
class A
{
friend class B; // 友元B类可以访问A中的任何成员
public:
const static int _x = 2;
protected:
static double _a;
private:
int _b = 0;
};
double A::_a = 1;
class B
{
public:
void func()
{
cout << a._a << endl;
cout << a._b << endl;
cout << a._x << endl;
}
A a;
};
void test2()
{
B b;
cout << b.a._x << endl;
cout << "-----------" << endl;
b.func();
}
- 友元关系是单向的,不具有交换性
eg:以上面代码为例,类A就只能访问类B的公有成员。- 友元关系不能传递
eg:如果C是B的友元, B是A的友元,则不能说明C时A的友元。
🍈内部类
概念:如果一个类定义在另一个类的内部,这个内部类就叫做内部类。内部类是一个独立的类,它不属于外部类,更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
注意:内部类就是外部类的友元类,参见友元类的定义,内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
- 特性
- 内部类可以定义在外部类的public、protected、private都是可以的。
- 注意内部类可以直接访问外部类中的static成员,不需要外部类的对象/类名。
- sizeof(外部类)=外部类,和内部类没有任何关系
🍊匿名对象
通俗理解,就是没有名字的对象。常用**类名加括号(根据构造函数来定义)**的方式来创建eg:A()
,如图:
class A
{
public:
A(int n = -1) { cout << "A()" << endl; }
A(const A& a) { cout << "A(const A &a)" << endl; }
~A(){
cout << "~A()" << endl;
}
};
void test2()
{
A(); // 匿名对象,生命周期就在这一行
f1(A(2)); // 匿名对象作为实际参数,用完就释放
}
🛸编译器对创建对象时的优化
编译器会对连续构造和拷贝构造进行优化,减少拷贝构造。
class A
{
public:
A(int n = -1) { cout << "A()" << endl; }
A(const A& a) { cout << "A(const A &a)" << endl; }
~A()
{
cout << "~A()" << endl;
}
};
void f1(A a) {}
A f2()
{
A aa;
return aa;
}
void test2()
{
// 隐式类型,连续构造+拷贝构造->优化为直接构造
//实际上有两次调用,
//1. 1作为实参隐式调用构造函数生成临时对象。
//2. 函数f1形参a生成,要调用拷贝构造函数
//编译器优化,只调用一次构造函数
f1(1);
// 一个表达式中,连续构造+拷贝构造->优化为一个构造
// 同理:1. 2作为隐式调用构造函数生成临时对象
// 2. 临时对象拷贝给匿名对象A
// 3. f1形参a拷贝构造匿名对象A
// 编译器优化:只调用一次构造
f1(A(2));
cout << endl;
// 同理自推:
// 一个表达式中,连续拷贝构造+拷贝构造->优化一个拷贝构造
A aa2 = f2();
// 一个表达式中,连续拷贝构造+赋值重载->无法优化
A aa1;
aa1 = f2();
}