目录

再探构造函数：初始化列表

使用方法：

特点：

１、初始化列表是每个成员变量定义初始化的地方

２、每一成员变量在初始化列表只出现一次

3、必须在初始化列表中出初始化的成员变量

4、成员变量给缺省值

5、在构造函数体内初始化和在初始化列表中初始化有什么区别？

6、指针成员变量初始化

7、成员变量初始化顺序

注：()和{}初始化使用

总结：

类型转换

static成员

静态成员的调用：

静态成员变量：

1、

2、

​编辑3、

静态成员函数：

1、

2、

3、

注：静态成员也受访问限定符的限制

代码：

友元

内部类

匿名对象

特点：

1、

2、

3、使用场景

4、

5、匿名对象和临时对象的区别

---

再探构造函数：初始化列表

在前面构造函数的学习中，成员变量的初始化主要在函数体内赋值，但还有一种初始化的方法，就是：初始化列表

使用方法：

在函数名下，以一个冒号开头，接着是一个以逗号分隔的数据成员列表，每一个成员变量后面跟一个放在括号中的初始值或表达式

class A
{
public:A():_a1(0)//成员变量初始化, _a2(0){}
private:int _a1;int _a2;
};int main()
{A a(1,1);//对象初始化return 0;
}

特点：

１、初始化列表是每个成员变量定义初始化的地方

在语法上可以这么理解：初始化列表是每个成员变量定义初始化的地方

２、每一成员变量在初始化列表只出现一次

class A
{
public:A():_a1(0)//,_a1(1)//error, _a2(0){}
private:int _a1;int _a2;
};

3、必须在初始化列表中出初始化的成员变量

1、引用成员变量

2、const成员变量

3、没有默认构造函数的类类型成员变量

正确代码：

class B
{
public:B(int b){_b = b;}
private:int _b;
};class A
{
public:A(int a1, int a2):_a1(a1), _a2(a2), _a3(1), _a4(1), _a5(1){}
private:int _a1;int _a2;//必须在初始化列表上初始化的成员变量const int _a3;const int& _a4;//没有默认构造的自定义类型成员变量也必须在初始化列表上初始化B _a5;
};int main()
{A a1(1, 1);return 0;
}

4、成员变量给缺省值

可以在成员变量声明时给缺省值，这里的缺省值其实就是给初始化列表的，当成员变量给了缺省值时，初始化列表就按照缺省值初始化成员变量

class B
{
public:B(int b){_b = b;}
private:int _b;
};class A
{
public:A(int a1, int a2){}
private:int _a1 = 0;int _a2 = 0;const int _a3 = 1;const int& _a4 = 1;B _a5 = 1;
};int main()
{A a1(1, 1);return 0;
}

5、在构造函数体内初始化和在初始化列表中初始化有什么区别？

//函数体内就相当于下面这种：
int i;
i = 1;
//初始化列表中初始化就相当于：
int i = 1;

6、指针成员变量初始化

class A
{public:A(int n):_a((int*)malloc(n)){}private:int* _a;//指针成员变量//int* _a = (int*)malloc(n);
}

7、成员变量初始化顺序

初始化列表中按照成员变量在类中声明顺序进行初始化，和在初始化列表中出现的顺序无关

所以成员变量声明顺序和初始化列表中顺序要保持一致

注：()和{}初始化使用

注意事项：
//int i(1);//error
int i{ 1 };//可以用{}来初始化，不能用()

总结：

在成员变量初始化的时候尽量走初始化列表，在编译器中即使不写出初始化列表或者不在初始化列表中初始化的成员变量，也会自动走初始化列表

当成员变量在声明时写了缺省值时，初始化列表会按照缺省值进行初始化(初始化列表中没有初始化赋值)

所以，以后成员变量初始化时一般都用初始化列表或给缺省值

类型转换

1、C++支持内置类型隐式转换为类类型对象，但需要相应的内置类型的构造函数

在C++11后支持多参数隐式转换

class A
{
public:A(int a):_a =a{}A(int a1,int a2):_a1(a1),_a2(a2){}
private:int _a1 = 1;int _a2 = 1;
}int main()
{A a=1;const A& a1 = 1;A a2(1,2);return 0;
}

代码中的隐式类型转换会涉及构造函数和拷贝构造函数，中间产生临时变量，但经过编译器的优化，就只会有一个直接构造函数

2、构造函数前面加上explicit就不会支持隐式类型转换

class A
{
public:explicit A(int a)//加上explicit关键字:_a1(a){}
private:int _a1 = 1;
};int main()
{A a=1;return 0;
}

3、类与类之间也可以进行隐式类型转换，但也需要对应的构造函数支持

它的原理与内置类型隐式类型转换为自定义类型相同

class A
{
public://explicit A(int a)//加上explicit关键字，就不支持隐式类型转换A(int a)//内置类型与自定义类型:_a(a){}int Get() const{return _a;}
private:int _a = 1;
};class B
{
public:B(const A& a):_b(a.Get()){}
private:int _b = 0;
};int main()
{A a = 1;B b = a;return 0;
}

static成员

静态成员的调用：
 

静态成员变量：

1、

用static关键字修饰的成员变量被称为静态成员变量，静态成员变量在类内声明，但必须在类外初始化

class A
{
public:private://类中声明static int a;
};//类外初始化
int A::a = 1;

2、

静态成员变量是属于所有该类的对象的，而不是专属于某一个对象，它不存在对象中，存放于静态区

3、

静态成员变量不能在声明处给缺省值，因为静态成员变量不走初始化列表，由前文可知：给成员变量的缺省值是给初始化列表

class A
{
public:private://类中声明static int a;//static int a = 1;//error:不能再类中初始化
};//类外初始化
int A::a = 1;

静态成员函数：

1、

用static修饰的成员函数，它没有this指针，而且它不能使用类型限定符

2、

因为它没有this指针，所以它只可以访问静态成员函数和静态成员变量，非静态成员是不能访问的

3、

非静态成员可以任意访问静态成员

注：静态成员也受访问限定符的限制

代码：

class A
{
public:A(){a++;}void Print() const{cout << a << endl;}//static int GetA() const//静态成员函数不能使用类型限定符static int GetA(){return a;}
private://类中声明static int a;//static int a = 1;//error:不能再类中初始化
};//类外初始化
int A::a = 1;int main()
{/*cout << A::a << endl;*/cout << A::GetA() << endl;A a1;a1.Print();cout << a1.GetA() << endl;A a2;a2.Print();return 0;
}

友元

1、友元提供了⼀种突破类访问限定符封装的⽅式，友元分为：友元函数和友元类，在函数声明或者类声明的前⾯加friend，并且把友元声明放到⼀个类的⾥⾯。

2、外部友元函数可访问类的私有和保护成员，友元函数仅仅是⼀种声明，他不是类的成员函数

3、友元函数可以在类定义的任何地⽅声明，不受类访问限定符限制。

4、⼀个函数可以是多个类的友元函数。

5、友元类中的成员函数都可以是另⼀个类的友元函数，都可以访问另⼀个类中的私有和保护成员。

6、友元类的关系是单向的，不具有交换性，⽐如A类是B类的友元，但是B类不是A类的友元。

7、友元类关系不能传递，如果A是B的友元， B是C的友元，但是A不是C的友元。

内部类

这一部分了解就可以了

一个类被定义在另一个类中，就叫做内部类

class A
{
public:class B//内部类{};
};int main()
{A::B b1;return 0;
}

内部类是一个独立的类，它和定义在全局的类的相比就只是会被外部类的类域和访问限定符的限制，所以外部类实例化的类中不包含内部类

内部类在C++中用的比较少，在Java中用得较多

匿名对象

特点：

1、

用类型定义出来的对象就叫做匿名对象，而我们之前定义的类型对象是叫有名对象

A();//匿名对象

2、

匿名对象的生命周期只在当前这一行，如果当需要临时定义一个对象使用，就可以定义匿名对象

3、使用场景

1、在调用成员函数时：

class A
{
public:int f1(){return _a;}private:int _a = 1;
};int main()
{//之前A a1;cout << a1.f1() << endl;//使用匿名对象cout << A().f1() << endl;return 0;
}

2、做缺省参数

void f2(const A& a = A())//做缺省值
{}

4、

匿名对象具有常性

class A
{
public:A():_a(1){}
private:int _a;
};int main()
{const A& a1 = A();return 0;
}

5、匿名对象和临时对象的区别

匿名对象是我们主动创建的，而临时对象是编译器创建的