目录
一、初始化列表
1、定义
2、注意事项
3、尽量使用初始化列表初始化
4、初始化顺序
二、 explicit关键字
1、定义
2、特点
三、static成员
1、定义
2、特性
3、例题
一、初始化列表
下面这段代码可以正常编译：
class A {
private:
int _a1;//成员声明
int _a2;
};
int main()
{
A a;//对象整体定义
return 0;
}
如果加上一个const类型的成员变量_x，编译就无法通过。
class A {
private:
int _a1;
int _a2;
const int _x;
};
int main()
{
A a;
return 0;
}
这是因为const变量必须在定义的位置初始化，否则编译不通过。
class A {
private:
int _a1;//声明
int _a2;
const int _x;
};在private作用域中，const变量和两个int变量都是成员变量的声明，如果我们声明const变量，一定要对它进行定义，那我们在哪定义呢？
C++11之后可以在声明位置为变量赋初值。
const int _x = 0;那在C++11之前，也有解决方法，给每个成员变量找一个位置对其进行定义，这样就解决了变量初始化的问题，这个位置使用初始化列表进行初始化赋值。
1、定义
初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。
class A {
public:
A()
:_x(1)
{}
private:
int _a1;
int _a2;
const int _x;
};
int main()
{
A a;
return 0;
}只要对象调用构造函数，初始化列表是它所有成员变量定义的位置。
不管是否显示在初始化列表写，那么编译器每个变量都会初始化列表定义初始化。
class A {
public:
A()
:_x(1),_a1(6)
{}
private:
int _a1 = 1;
int _a2 = 2;
const int _x;
};
int main()
{
A a;
return 0;
}在初始化列表中初始化的变量，不使用缺省值；没有使用初始化列表的变量，使用缺省值。 
2、注意事项
- 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
- 类中包含以下成员，必须放在初始化列表位置进行初始化：
- 引用成员变量
- const成员变量
- 自定义类型成员(且该类没有默认构造函数时)
class B {
public:
B():_b(0)
{
cout << "B()" << endl;
}
private:
int _b;
};
class A {
private:
B _bb;
};
int main()
{
A aa;
return 0;
}这里的aa的成员变量自定义类型_bb是可以调用它的默认构造函数的初始化列表进行初始化。
默认构造可以是无参或全缺省的。
class B {
public:
B(int n) :_b(0)//会报错
B(int n=9) :_b(0)//全缺省
B( ) :_b(0)//无参
private:
int _b;
};3、尽量使用初始化列表初始化
下面看一个用两个栈实现的队列。
typedef int DataType;
class Stack
{
public:
Stack(size_t capacity = 10)
{
cout << "Stack(size_t capacity = 10)" << endl;
_array = (DataType*)malloc(capacity * sizeof(DataType));
if (nullptr == _array)
{
perror("malloc申请空间失败");
exit(-1);
}
_size = 0;
_capacity = capacity;
}
void Push(const DataType& data)
{
_array[_size] = data;
_size++;
}
Stack(const Stack& st)
{
cout << "Stack(const Stack& st)" << endl;
_array = (DataType*)malloc(sizeof(DataType)*st._capacity);
if (nullptr == _array)
{
perror("malloc申请空间失败");
exit(-1);
}
memcpy(_array, st._array, sizeof(DataType)*st._size);
_size = st._size;
_capacity = st._capacity;
}
~Stack()
{
cout << "~Stack()" << endl;
if (_array)
{
free(_array);
_array = nullptr;
_capacity = 0;
_size = 0;
}
}
private:
DataType *_array;
size_t _size;
size_t _capacity;
};
class MyQueue
{
public:
MyQueue(int pushN, int popN)
:_pushST(pushN)
, _popST(popN)
{}
private:
Stack _pushST;
Stack _popST;
int _size = 0;
};
int main()
{
MyQueue q(2, 3);
return 0;
}在调试中可以看到，这里的2和3分别作为参数传递给MyQueue的构造函数，通过初始化列表对这两个成员变量进行初始化。
如果我们使用这种无参的构造函数对MyQueue对象初始化呢？
class MyQueue
{
public:
MyQueue()
{}
private:
Stack _pushST;
Stack _popST;
int _size = 0;
};可以看到，如果我们不写初始化列表，MyQueue类也可以调用Stack的默认构造函数对两个Stack类的对象进行初始化，不写MyQueue的构造函数也会使用同样方式初始化，本质上一样。
4、初始化顺序
成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。
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();
}_a2比_a1先声明，所以_a2比_a1先在初始化列表中初始化，_a2初始化时_a1还没初始化，所以_a2是随机值。
二、 explicit关键字
class A {
public:
A(int a):_a1(a)
{}
private:
int _a2;
int _a1;
};
int main()
{
A aa1(1); //构造函数
A aa2 = 1; //隐式类型转换
int i = 1;
double d = i;//隐式类型转换
return 0;
}默认情况下，这里的隐式类型转换都会借助额外创建的临时变量实现，通过构造创建临时变量，然后拷贝构造给变量赋值的过程被优化为直接构造，下一篇文章详细讲解优化过程。
在这两种情况下，临时变量的创建是为了完成类型转换的过程。这些临时变量在转换完成后会被销毁，对于程序的其他部分是不可见的。这种临时变量的创建和销毁是由编译器自动处理的，无需手动干预。
-
A aa2 = 1;这里发生了从int到A的隐式类型转换。编译器会自动调用A类的构造函数来创建一个临时的A对象，然后将整数值1传递给构造函数作为参数。这个临时的A对象会被复制到aa2中，完成隐式类型转换。 -
double d = i;这里发生了从int到double的隐式类型转换。编译器会创建一个临时的double变量，并将整数变量i的值复制到这个临时变量中。然后，这个临时的double变量的值会被赋给变量d，完成隐式类型转换。
拷贝构造也属于构造，也可以使用初始化列表，但下面的成员变量会调用拷贝构造吗？
class A
{
public:
A(int a)
:_a1(a)
{
cout << "A(int a)" << endl;
}
A(const A& aa)
:_a1(aa._a1)
{
cout << "A(const A& aa)" << endl;
}
private:
int _a2;
int _a1;
};
int main()
{
A aa1(1); //构造函数
A aa2 = 1; //隐式类型转换
return 0;
}
输出结果发现没有调用引用类型的拷贝构造。
这是因为C++中编译器会对自定义类型的进行优化， 将构造+拷贝+优化的过程优化成一个构造。
那下面的代码中，为什么第一个会报错，第二个没问题呢？
A& ref = 10;
const A& ref = 10;
- 这是因为在C++中，当你声明一个引用（比如
A& ref）并试图将其初始化为一个右值（比如一个临时对象或一个字面量），编译器通常会报错。这是因为非const引用不能绑定到右值上，防止对临时对象的非常量引用，因为这可能导致对临时对象的意外修改，从而导致不确定的行为。但是，当你声明一个常量引用（比如const A& ref），编译器允许这种绑定，因为常量引用可以绑定到右值上。 - 在上述代码中，
const A& ref = 10;这行代码中的10是一个整数字面量，是一个右值。你尝试将这个右值绑定到引用ref上。由于ref被声明为const A&，它是一个常量引用，所以编译器允许这种绑定，并调用A类的构造函数A(int a)来创建一个临时的A对象，然后将ref绑定到这个临时对象上。
1、定义
对于单参构造函数：没有使用explicit修饰，具有类型转换作用explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译。
对于刚刚的代码，如果在构造函数前加explicit程序会怎么样呢？
class A{
public:
explicit A(int a)
:_a1(a)
{
cout << "A(int a)" << endl;
}
A(const A& aa)
:_a1(aa._a1)
{
cout << "A(const A& aa)" << endl;
}
private:
int _a2;
int _a1;
};
int main()
{
A aa1(1); //构造函数
A aa2 = 1; //隐式类型转换
const A& ref = 10;
return 0;
}这两段代码会报错，程序禁止类型转换。
2、特点
class A
{
public:
//explicit A(int a)
A(int a)
:_a1(a)
{
cout << "A(int a)" << endl;
}
//explicit A(int a1, int a2)
A(int a1, int a2)
:_a1(a1)
, _a2(a2)
{}
private:
int _a2;
int _a1;
};
int main()
{
// 单参数构造函数 C++98
A aa1(1); //构造函数
A aa2 = 1; //隐式类型转换
// 多参数构造函数 C++11
A aa2(1, 1);
//A aa3= 2，2;//C98不支持
A aa3 = { 2, 2 };//C++11支持
return 0;
}-
A aa1(1);这是直接调用单参数构造函数创建对象的例子。 -
A aa2 = 1;这是一个隐式类型转换的例子。这里，整数1被隐式地转换为类A的一个对象。这是因为类A定义了一个接受int类型参数的构造函数，因此编译器会自动调用该构造函数来创建一个临时的A对象，并将其赋值给aa2。 -
A aa2(1, 1);这是直接调用双参数构造函数创建对象的例子。 -
A aa3 = { 2, 2 };这是C++11引入的列表初始化的例子。这种方式可以用来初始化对象，而不需要显式地调用构造函数。
explicit关键字用于阻止编译器进行不希望发生的隐式类型转换。如果你将构造函数前面的注释去掉，使得构造函数前面有explicit关键字，那么像A aa2 = 1;这样的隐式类型转换就会被禁止，编译器会报错。
例如，如果你将单参数构造函数改为explicit A(int a)，那么A aa2 = 1;这行代码就会导致编译错误，因为编译器被禁止进行从int到A的隐式类型转换。你必须显式地调用构造函数，像A aa2(1);这样。
总的来说，explicit关键字可以帮助你控制类型转换，防止因为不希望的隐式类型转换而导致的错误。
三、static成员
实现一个类，计算程序中创建了多少类对象
int count = 0;
class A
{
public:
A(int a = 0)
{
++count;
}
A(const A& aa)
{
++count;
}
};
void func(A a)
{}
int main()
{
A aa1;
A aa2(aa1);
func(aa1);
A aa3 = 1;
cout << count << endl;
return 0;
}造成了命名冲突的问题，因为C++的xutility文件里有个函数count与我们定义的全局变量count冲突了。
我们可以不展开std，只调用需要用的流输入输出即可。
#include <iostream>
//using namespace std;
using std::cout;
using std::endl;成功输出：
C++为了解决上述问题，同时可以将std展开，将count作为类的static修饰的成员即可实现。
1、定义
- 声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；
- 用static修饰的成员函数，称之为静态成员函数。
- 静态成员变量一定要在类外进行初始化。
- 静态成员不属于某个对象，所于所有对象，属于整个类。
- 静态成员变量的初始化通常在类外部进行。
class A
{
public:
A(int a = 0)
{
++count;
}
A(const A& aa)
{
++count;
}
int Getcount()
{
return count;
}
private:
static int count; // 此处为声明
int _a = 0;
};
int A::count = 0; // 定义初始化
void func(A a)
{}当我们想输出时：
int main()
{
A aa1;
A aa2(aa1);
func(aa1);
A aa3 = 1;
cout << A::Getcount() << endl;
return 0;
}
如果想要输出，可以使用静态成员函数。
//静态成员函数 没有this指针
static int Getcount()
{
// _a++; // 不能直接访问非静态成员
return count;
}成功输出：
下面语句创建出了多少个类对象？
A aa4[10];输出结果：
2、特性
- 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
- 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
- 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
- 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
- 静态成员也是类的成员，受public、protected、private 访问限定符的限制
3、例题
求1+2+3+...+n_牛客题霸_牛客网 (nowcoder.com)
- 下面这段代码实现了一个类
Sum和一个类Solution，其中Sum类用于计算从1到n的累加和，而Solution类则使用Sum类来计算给定整数n的累加和。- 这种设计利用了类的构造函数和静态成员变量的特性，实现了累加和的计算和获取。
class Sum{
public:
Sum()
{
_sum+=_i;
_i++;
}
static int Getsum()
{
return _sum;
}
private:
static int _sum;
static int _i;
};
int Sum::_sum = 0;
int Sum::_i = 1;
class Solution {
public:
int Sum_Solution(int n) {
Sum a[n];
return Sum::Getsum();
}
};首先，让我们逐步解释 Sum 类的实现：
Sum类有两个静态成员变量_sum和_i，分别用于保存累加和和当前的计数器值。- 构造函数
Sum()是一个无参构造函数，每次被调用时，它会将当前计数器值_i加到累加和_sum中，并将计数器_i自增1。 - 静态成员函数
Getsum()用于获取累加和_sum的值。
接下来，我们来看 Solution 类的实现：
Solution类中的成员函数Sum_Solution(int n)接受一个整数n作为参数，并返回从1到n的累加和。- 在
Sum_Solution函数中，我们创建了一个名为a的Sum类型的数组，数组的大小为n。 - 由于
Sum类的构造函数会在创建对象时自动调用，因此创建数组a的过程中，会依次调用Sum类的构造函数，从而实现了从1到n的累加和的计算。 - 最后，我们通过调用
Sum::Getsum()函数来获取累加和的值，并将其作为函数的返回值。
![[Linux] 正则表达式及grep和awk](https://img-blog.csdnimg.cn/c3ec0e4d87674ef6b828f087e961ceb4.png)
