目录
一、初始化列表
下面这段代码可以正常编译：
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修饰的成员函数，称之为静态成员函数。
2、特性
- 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
- 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
- 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
- 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
- 静态成员也是类的成员，受public、protected、private 访问限定符的限制
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;
}成功输出：
静态成员函数可以调用非静态成员函数吗？
答案是“否”。静态成员函数没有隐含的 this 指针，因此无法访问任何特定对象的非静态成员函数或非静态成员变量。非静态成员函数依赖于特定的对象实例（通过 this 指针）来访问和操作非静态成员变量和函数。在静态成员函数内部，不能直接访问非静态成员。
非静态成员函数可以调用类的静态成员函数吗？
是的，非静态成员函数可以调用类的静态成员函数。非静态成员函数在执行时可以直接通过类名或者对象名访问静态成员函数。静态成员函数不依赖于特定的类实例，因此可以被任何实例或者类直接调用。
下面语句创建出了多少个类对象？
A aa4[10];输出结果：
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()函数来获取累加和的值，并将其作为函数的返回值。