前言
在谈论C++时，常常会涉及到一些高级特性和概念，比如初始化列表、static成员、友元、内部类、匿名对象等。这些概念在C++编程中起着非常重要的作用，对于想要深入了解C++语言的开发者来说，掌握这些知识是至关重要的。本文，我们将深入探讨这些概念，探讨它们的作用以及如何在实际中的应用。
1. 再谈构造函数
1.1 初始化列表
提到初始化列表，那就要再次谈及构造函数，初始化列表属于构造函数进行初始化的一种方式。
class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};这是最开始所说的构造函数初始化的一种方法，这种方法实质上不能被成为初始化，构造函数体中的语句只能将其称为赋初值，初始化只能初始化一次，而构造函数体内可以多次赋值。
回到初始化列表。
初始化列表：以一个冒号开始，逗号分割，每个" 成员变量 "后面跟一个放在括号中的初始值或表达式。
比如：
class Date
{
public:
Date(int year, int month, int day)
: _year(year)
, _month(month)
, _day(day)
{}
private:
int _year;
int _month;
int _day;
};定义一个类的对象时是这样的：
Date d1(2023,11,20);这是对象的整体定义，成员变量的定义在哪儿？就是在初始化列表。
每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)。
对于一些特殊情况，就必须要使用初始化列表进行初始化：
- 引用成员变量
- const成员变量
- 自定义类型成员(且该类没有默认构造函数时)
初始化列表也可以与构造函数函数体内初始化结合使用：
这个是一个测试样例：
class A
{
public:
A(int a)
:_a(a)
{}
private:
int _a;
};
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
_n = 1; //报错：error C2530: “Date::_ref”: 必须初始化引用
_ref = year; //报错：error C2789: “Date::_n”: 必须初始化常量限定类型的对象
}
private:
int _year;
int _month;
int _day;
int& _ref;
const int _n;
};_ref和_n如果在函数体内初始化就会报错，const修饰会让其具备常属性，也就是说该变量只能在定义时初始化，引用类型也是，在定义时必须要初始化。
正确的构造函数写法应该是：
Date(int year, int month, int day)
: _n(1)
, _ref(_year)
{
_year = year;
_month = month;
_day = day;
}接下来就是它在C++语法设计时的细节问题：
class Date
{
public:
Date(int year, int month, int day)
: _n(1) //类成员定义
, _ref(year)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
int& _ref;
const int _n;
};
int main()
{
Date d1(2023, 11, 20);// 对象整体定义
return 0;
}这里C++语法设计的有点过于复杂，构造函数执行完初始化列表内容之后，函数体内的成员变量也已经被定义
在没有执行赋值初始化操作之前，内置类型默认的随机值（但此时的全部成员变量都是已经被定义了的）。
其次就是自定义类型：
测试代码，比如：
class A
{
public:
A(int a = 0) //注意这里给了缺省值
:_a(a)
{}
private:
int _a;
};
class Date
{
public:
Date(int year, int month, int day)
: _n(1)
, _ref(year)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
int& _ref;
const int _n;
A _obj;
};
int main()
{
Date d1(2023, 11, 20);
return 0;
}注意观察以下调试过程：
在初始化列表进行初始化时，自定义类型会自动调用默认构造函数。
注意：自定义类型A在构造函数中给了缺省值！！！
如果不给缺省值，就会直接报错（没有默认构造函数）： error C2512: “A”: 没有合适的默认构造函数可用
解决方法有两种：
- 在A的构造函数中给缺省值
- 使用初始化列表
Date(int year, int month, int day)
: _n(1)
, _ref(year)
, _obj(10)
{
_year = year;
_month = month;
_day = day;
}之前我们提到C++打补丁支持声明时给缺省值：
class Date
{
public:
Date(int year, int month, int day)
: _n(1)
, _ref(year)
, _obj(10)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year = 1; //在声明中给缺省值
int _month;
int _day;
int& _ref;
const int _n;
A _obj;
};这个缺省值其实就是给初始化列表的，在初始化列表中如果没有显示要求初始化就会使用这里的缺省值。
- 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化
当然也有初始化列表无法完成的情况：
有些初始化或检查的任务，初始化列表无法完成，比如：
class Stack
{
public:
Stack(int n = 2)
:_a((int*)malloc(sizeof(int)*n))
,_top(0)
,_capacity(n)
{
if (_a == nullptr)
{
perror("malloc fail");
exit(-1);
}
memset(_a, 0, sizeof(int) * n);
}
private:
int* _a;
int _top;
int _capacity;
};使用函数初始化数组的值，或者是开空间失败后的异常处理。
- 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关
看以下这个代码：
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();
}它的输出结果是什么？
答案是_a1 = 1和_a2 = 随机值，声明次序就是其在初始化列表中的初始化顺序。所以它先初始化的是_a2，_a2使用_a1的值进行初始化，但此时_a1还未执行初始化，此时的_a1为随机值。
1.2 explicit关键字
看下面这段代码：
class A
{
public:
A(int a)
:_a(a)
{}
int _a = 0;
};
void Test()
{
A a1(1);
A a2 = 2;// 内置类型隐式转换成自定义类型
}a2在进行初始化时发生了隐式转换：实际编译器背后会用2构造一个无名对象，最后用无名对象给a2对象进行赋值。
能支持整形2转换，是有A的int 单参数构造函数支持，如果使用int* 类型就不支持隐式类型转换了。
想要支持可以添加一个含int* 的单参数构造函数：
class A
{
public:
A(int a)
:_a(a)
{}
A(int* p)
{}
int _a = 0;
};如果不想让这个隐式类型转换（强制类型转换还是可以的），就可以使用explicit关键字来修饰构造函数。
class A
{
public:
explicit A(int a)
:_a(a)
{}
int _a = 0;
};前边的示例是单参数，那多参数呢？
class Date
{
public:
Date(int year, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{}
private:
int _year;
int _month;
int _day;
};如上，也是可以的，支持一个传参的半缺省（全缺省也可以）也是可以隐式类型转换。那可不可以支持多个内置类型隐式转换，C++11是可以的：
Date d1 = { 2023, 11, 10 };但是只能如上这种写法。
多参数也是一样，如果不想要隐式类型转换，可以给构造函数加explicit。
2. static成员
static修饰有什么作用？
static修饰的成员变量或成员函数在类加载时执行，并且只会执行一次。
问题：实现一个类，计算程序中创建出了多少个类对象
使用全局变量计算：
int n = 0;
class A
{
public:
A() { ++n; }
A(const A& t) { ++n; }
~A() {}
private:
};
A func()
{
A aa;
return aa;
}
int main()
{
n++;
A aa;
func();
n++;
cout << n << endl;
return 0;
}当前边存在修改n的情况，结果就不准确了，其次就是每次使用时都要将n置为0（其他类也可能使用过n）；那有没有专属这个类的计数变量呢？使用static就可以很好的解决这个问题。
2.1 概念
用static修饰的成员变量，称之为静态成员变量；
用static修饰的成员函数，称之为静态成员函数。
静态成员变量一定要在类外进行初始化
class A
{
public:
A() { ++count; }
A(const A& t) { ++count; }
~A() {}
static int GetACount() { return count; }
private:
static int count;
};
int A::count = 0;
A func()
{
A aa;
return aa;
}
int main()
{
A aa;
func();
cout << A::GetACount() << endl;
return 0;
}2.2 特点
- 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
- 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
- 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
- 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
- 静态成员也是类的成员，受public、protected、private 访问限定符的限制
总结：静态成员变量和静态成员函数，可以理解为受限制的全局变量和全局函数。专属于某个类，受类域和访问限定符的限制。
3. 匿名对象
匿名对象其实很简单我们看下面这个代码：
class Date
{
public:
Date(int year, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{}
private:
int _year;
int _month;
int _day;
};
int main()
{
vector<Date> v;
Date d1(2023, 11, 1);
v.push_back(d1);
return 0;
}在C++中的STL容器中我们要存储日期类的对象。每次存储还要创建一个对象，然后再存储，这样很麻烦，这里我们就可以使用匿名函数：
v.push_back(Date(2023, 10, 31));匿名对象在这样场景下就很好用。匿名对象的生命周期只有这一行，执行完之后自动调用析构函数。
4. 友元
友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以
友元不宜多用
友元分为：友元函数和友元类
4.1 友元函数
友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字
前边在实现Date类的流插入、流提取中提到过。
友元函数的特点：
- 友元函数可访问类的私有和保护成员，但不是类的成员函数
- 友元函数不能用const修饰
- 友元函数可以在类定义的任何地方声明，不受类访问限定符限制
- 一个函数可以是多个类的友元函数
- 友元函数的调用与普通函数的调用原理相同
4.2 友元类
友元类（friend class）是指一个类可以访问另一个类的私有成员和保护成员。
比如：
class A {
private:
int privateData;
protected:
int protectedData;
friend class B; // B是A的友元类
};
class B {
public:
void accessA(A& a) {
// 友元类B可以访问A的私有成员和保护成员
a.privateData = 10;
a.protectedData = 20;
}
};
注意：
- 友元关系是单向的
比如：类A声明类B为友元类，那么类B可以访问类A的私有成员和保护成员，但类A不能访问类B的私有成员和保护成员。
- 友元关系不能传递
如果C是B的友元， B是A的友元，则不能说明C时A的友元
- 友元关系不能继承
5. 内部类
什么是内部类？
一个类定义在另一个类的内部
内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限
比如：
class A
{
private:
int h;
public:
class B // B天生就是A的友元
{
public:
void fun(const A& a)
{
cout << a.h << endl;//OK
}
};
};
A于B的关系：
可以理解为B就是一个普通类，它只受A的类域和访问限定符限制，
int main()
{
A aa;
//B bb //error C2065: “B”: 未声明的标识符
A::B bb;
cout << sizeof(A) << endl; // 4
return 0;
}内部类天生就是外部类的友元
*6. 拷贝构造时的一些优化
在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝。
比如：
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;
};
int main()
{
A aa1 = 1;
return 0;
}A aa1 = 1;
它的过程是什么样的？它的过程其实分为两步
1、先用1构造一个临时对象 2、再用临时对象拷贝构造aa1
但我们在调试时会发现最终编译器显示的是一次构造。这其实就是由于编译器的优化。
同一个表达式中，连续构造+构造 / 构造+拷贝构造 / 拷贝构造+拷贝构造 会合二为一
合并规则如下：
- 构造+构造->构造
- 构造+拷贝构造->构造
- 拷贝构造+拷贝构造->拷贝构造
编译器不同优化效果也不同，老的编译器不会怎么优化，但新的编译器基本都会做这样的优化，甚至优化的比这个更厉害。
总结
在C++编程中，掌握初始化列表、static成员、友元和内部类等相关知识是非常重要的。这些概念不仅能够帮助我们更好地理解C++语言的特性，还能够提高我们的编程效率和代码质量，以上便是本文全部内容，希望可以对你有所帮助，感谢阅读！
