【C++初阶】类与对象(下)

目录
再探构造函数：初始化列表
使用方法：
特点：
１、初始化列表是每个成员变量界说初始化的地方
２、每一成员变量在初始化列表只出现一次
3、必须在初始化列表中出初始化的成员变量
4、成员变量给缺省值
5、在构造函数体内初始化和在初始化列表中初始化有什么区别？
6、指针成员变量初始化
7、成员变量初始化次序
注：()和{}初始化使用
总结：
类型转换
static成员
静态成员的调用：
静态成员变量：
1、
2、
​编辑3、
静态成员函数：
1、
2、
3、
注：静态成员也受访问限定符的限制
代码：
友元
内部类
匿名对象
特点：
1、
2、
3、使用场景
4、
5、匿名对象和暂时对象的区别

---

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

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

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

1. class A
2. {
3. public:
4.         A()
5.          :_a1(0)//成员变量初始化
6.          , _a2(0)
7.         {
8.                
9.         }
10. private:
11.         int _a1;
12.         int _a2;
13. };
15. int main()
16. {
17.     A a(1,1);//对象初始化
18.     return 0;
19. }

复制代码

特点：

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

在语法上可以这么理解：初始化列表是每个成员变量界说初始化的地方
２、每一成员变量在初始化列表只出现一次

1. class A
2. {
3. public:
4.         A()
5.                 :_a1(0)
6.       //,_a1(1)//error
7.                 , _a2(0)
8.         {
9.                
10.         }
11. private:
12.         int _a1;
13.         int _a2;
14. };

复制代码

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

   1、引用成员变量
  2、const成员变量
  3、没有默认构造函数的类类型成员变量
  

正确代码：

1. class B
2. {
3. public:
4.         B(int b)
5.         {
6.                 _b = b;
7.         }
8. private:
9.         int _b;
10. };
13. class A
14. {
15. public:
16.         A(int a1, int a2)
17.                 :_a1(a1)
18.                 , _a2(a2)
19.                 , _a3(1)
20.                 , _a4(1)
21.                 , _a5(1)
22.         {
23.         }
24. private:
25.         int _a1;
26.         int _a2;
27.        
28.         //必须在初始化列表上初始化的成员变量
29.         const int _a3;
30.         const int& _a4;
31.         //没有默认构造的自定义类型成员变量也必须在初始化列表上初始化
32.         B _a5;
33. };
35. int main()
36. {
37.         A a1(1, 1);
38.         return 0;
39. }

复制代码

4、成员变量给缺省值

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

1. class B
2. {
3. public:
4.         B(int b)
5.         {
6.                 _b = b;
7.         }
8. private:
9.         int _b;
10. };
12. class A
13. {
14. public:
15.         A(int a1, int a2)
16.         {
17.         }
18. private:
19.         int _a1 = 0;
20.         int _a2 = 0;
21.         const int _a3 = 1;
22.         const int& _a4 = 1;
23.     B _a5 = 1;
24. };
26. int main()
27. {
28.         A a1(1, 1);
29.         return 0;
30. }

复制代码

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

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

复制代码

6、指针成员变量初始化

1. class A
2. {
3. public:
4.     A(int n)
5.         :_a((int*)malloc(n))
6.     {
8.     }
9. private:
10.     int* _a;//指针成员变量
11.   //int* _a = (int*)malloc(n);
12. }

复制代码

7、成员变量初始化次序

初始化列表中按照成员变量在类中声明次序举行初始化，和在初始化列表中出现的次序无关
以是成员变量声明次序和初始化列表中次序要保持一致

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

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

复制代码

总结：

在成员变量初始化的时候尽量走初始化列表，在编译器中即使不写出初始化列表大概不在初始化列表中初始化的成员变量，也会自动走初始化列表
当成员变量在声明时写了缺省值时，初始化列表会按照缺省值举行初始化(初始化列表中没有初始化赋值)
以是，以后成员变量初始化时一般都用初始化列表或给缺省值
类型转换

1、C++支持内置类型隐式转换为类类型对象，但必要相应的内置类型的构造函数
在C++11后支持多参数隐式转换

1. class A
2. {
3. public:
4.     A(int a)
5.       :_a =a
6.     {
7.         
8.     }
9.     A(int a1,int a2)
10.       :_a1(a1)
11.       ,_a2(a2)
12.     {
13.         
14.     }
15. private:
16.     int _a1 = 1;
17.     int _a2 = 1;
18. }
20. int main()
21. {
22.     A a=1;
23.     const A& a1 = 1;
24.     A a2(1,2);
25.     return 0;
26. }

复制代码

代码中的隐式类型转换会涉及构造函数和拷贝构造函数，中心产生暂时变量，但颠末编译器的优化，就只会有一个直接构造函数
2、构造函数前面加上explicit就不会支持隐式类型转换

1. class A
2. {
3. public:
4.     explicit A(int a)//加上explicit关键字
5.       :_a1(a)
6.     {
7.         
8.     }
9. private:
10.     int _a1 = 1;
11. };
13. int main()
14. {
15.     A a=1;
16.     return 0;
17. }

复制代码

3、类与类之间也可以举行隐式类型转换，但也必要对应的构造函数支持
它的原理与内置类型隐式类型转换为自界说类型雷同

1. class A
2. {
3. public:
4.     //explicit A(int a)//加上explicit关键字，就不支持隐式类型转换
5.     A(int a)//内置类型与自定义类型
6.         :_a(a)
7.     {
9.     }
10.     int Get() const
11.     {
12.         return _a;
13.     }
14. private:
15.     int _a = 1;
16. };
18. class B
19. {
20. public:
21.         B(const A& a)
22.                 :_b(a.Get())
23.         {}
24. private:
25.         int _b = 0;
26. };
28. int main()
29. {
30.     A a = 1;
31.     B b = a;
32.     return 0;
33. }

复制代码

static成员

静态成员的调用：
 

静态成员变量：

1、

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

1. class A
2. {
3. public:
5. private:
6.         //类中声明
7.         static int a;
8. };
10. //类外初始化
11. int A::a = 1;

复制代码

2、

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

3、

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

1. class A
2. {
3. public:
5. private:
6.         //类中声明
7.         static int a;
8.         //static int a = 1;//error:不能再类中初始化
9. };
11. //类外初始化
12. int A::a = 1;

复制代码

静态成员函数：

1、

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

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

非静态成员可以恣意访问静态成员
注：静态成员也受访问限定符的限制

代码：

1. class A
2. {
3. public:
4.         A()
5.         {
6.                 a++;
7.         }
8.         void Print() const
9.         {
10.                 cout << a << endl;
11.         }
12.         //static int GetA() const//静态成员函数不能使用类型限定符
13.         static int GetA()
14.         {
15.                 return a;
16.         }
17. private:
18.         //类中声明
19.         static int a;
20.         //static int a = 1;//error:不能再类中初始化
21. };
23. //类外初始化
24. int A::a = 1;
26. int main()
27. {
28.         /*cout << A::a << endl;*/
29.         cout << A::GetA() << endl;
30.         A a1;
31.         a1.Print();
32.         cout << a1.GetA() << endl;
33.         A a2;
34.         a2.Print();
37.         return 0;
38. }

复制代码

友元

1、友元提供了⼀种突破类访问限定符封装的⽅式，友元分为：友元函数和友元类，在函数声明大概类声明的前⾯加friend，并且把友元声明放到⼀个类的⾥⾯。
2、外部友元函数可访问类的私有和保护成员，友元函数仅仅是⼀种声明，他不是类的成员函数
3、友元函数可以在类界说的任何地⽅声明，不受类访问限定符限制。
4、⼀个函数可以是多个类的友元函数。
5、友元类中的成员函数都可以是另⼀个类的友元函数，都可以访问另⼀个类中的私有和保护成员。
6、友元类的关系是单向的，不具有交换性，⽐如A类是B类的友元，但是B类不是A类的友元。
7、友元类关系不能传递，如果A是B的友元， B是C的友元，但是A不是C的友元。
内部类

这一部分了解就可以了
一个类被界说在另一个类中，就叫做内部类

1. class A
2. {
3. public:
4.         class B//内部类
5.         {
7.         };
8. };
10. int main()
11. {
12.         A::B b1;
13.         return 0;
14. }

复制代码

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

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

特点：

1、

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

1. A();//匿名对象

复制代码

2、

匿名对象的生命周期只在当前这一行，如果当必要暂时界说一个对象使用，就可以界说匿名对象
3、使用场景

   1、在调用成员函数时：

1. class A
2. {
3. public:
4.         int f1()
5.         {
6.                 return _a;
7.         }
9. private:
10.         int _a = 1;
11. };
13. int main()
14. {
15.         //之前
16.         A a1;
17.         cout << a1.f1() << endl;
18.         //使用匿名对象
19.         cout << A().f1() << endl;
20.         return 0;
21. }

复制代码

2、做缺省参数

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

复制代码

4、

匿名对象具有常性

1. class A
2. {
3. public:
4.         A()
5.         :_a(1)
6.         {
8.         }
9. private:
10.         int _a;
11. };
13. int main()
14. {
15.     const A& a1 = A();
16.         return 0;
17. }

复制代码

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

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




免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。