devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++内功修炼----面向对象之封装_c++静态和非静态类成员面向对象封装

作者：从前慢现在也慢 | 2024-03-14 10:58:13

赞

踩

c++静态和非静态类成员面向对象封装

0.概述
 

1.类的成员变量

 

可变成员变量mutable

在C++中，mutable也是为了突破const的限制而设置的。被mutable修饰的变量(mutable只能由于修饰类的非静态数据成员)，将永远处于可变的状态，即使在一个const函数中。

我们知道，假如类的成员函数不会改变对象的状态，那么这个成员函数一般会声明为const。但是，有些时候，我们需要在const的函数里面修改一些跟类状态无关的数据成员，那么这个数据成员就应该被mutalbe来修饰。

 

 

静态成员变量static

1、静态数据成员
在类内数据成员的声明前加上关键字static，该数据成员就是类内的静态数据成员。先举一个静态数据成员的例子。

复制代码

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. class Myclass
  5. {
  6. private:
  7.     int a , b , c;
  8.     static int sum;  //声明静态数据成员
  9. public:
  10.     Myclass(int a , int b , int c);
  11.     void GetSum();
  12. };
  13.  
  14. int Myclass::sum = 0;   //定义并初始化静态数据成员
  15.  
  16. Myclass::Myclass(int a , int b , int c)
  17. {
  18.     this->a = a;
  19.     this->b = b;
  20.     this->c = c;
  21.     sum += a+b+c;
  22. }
  23. void Myclass::GetSum()
  24. {
  25.     cout<<"sum="<<sum<<endl;
  26. }
  27.  
  28. int main(void)
  29. {
  30.     Myclass M(1 , 2 , 3);
  31.     M.GetSum();
  32.     Myclass N(4 , 5 , 6);
  33.     N.GetSum();
  34.     M.GetSum();
  35.     return 0;
  36. }

复制代码

可以看出，静态数据成员有以下特点：

  • 对于非静态数据成员，每个类对象都有自己的拷贝。而静态数据成员被当作是类的成员。无论这个类的对象被定义了多少个，静态数据成员在程序中也只有一份拷贝，由该类型的所有对象共享访问。也就是说，静态数据成员是该类的所有对象所共有的。对该类的多个对象来说，静态数据成员只分配一次内存，供所有对象共用。所以，静态数据成员的值对每个对象都是一样的，它的值可以更新；
  • 静态数据成员存储在全局数据区。静态数据成员定义时要分配空间，所以不能在类声明中定义。在Example 5中，语句int Myclass::Sum=0;是定义静态数据成员；
  • 静态数据成员和普通数据成员一样遵从public,protected,private访问规则；
  • 因为静态数据成员在全局数据区分配内存，属于本类的所有对象共享，所以，它不属于特定的类对象，在没有产生类对象时其作用域就可见，即在没有产生类的实例时，我们就可以操作它；
  • 静态数据成员初始化与一般数据成员初始化不同。静态数据成员初始化的格式为：
    ＜数据类型＞＜类名＞::＜静态数据成员名＞=＜值＞
  • 类的静态数据成员有两种访问形式：
    ＜类对象名＞.＜静态数据成员名＞ 或 ＜类类型名＞::＜静态数据成员名＞
    如果静态数据成员的访问权限允许的话（即public的成员），可在程序中，按上述格式来引用静态数据成员 ；
  • 静态数据成员主要用在各个对象都有相同的某项属性的时候。比如对于一个存款类，每个实例的利息都是相同的。所以，应该把利息设为存款类的静态数据成员。这有两个好处，第一，不管定义多少个存款类对象，利息数据成员都共享分配在全局数据区的内存，所以节省存储空间。第二，一旦利息需要改变时，只要改变一次，则所有存款类对象的利息全改变过来了；
  • 同全局变量相比，使用静态数据成员有两个优势：
  1. 静态数据成员没有进入程序的全局名字空间，因此不存在与程序中其它全局名字冲突的可能性；
  2. 可以实现信息隐藏。静态数据成员可以是private成员，而全局变量不能；

成员初始值

类成员初始化方式？

  1. 赋值初始化，通过在函数体内进行赋值初始化；列表初始化，在冒号后使用初始化列表进行初始化。

这两种方式的主要区别在于：

对于在函数体中初始化,是在所有的数据成员被分配内存空间后才进行的。

列表初始化是给数据成员分配内存空间时就进行初始化,就是说分配一个数据成员只要冒号后有此数据成员的赋值表达式(此表达式必须是括号赋值表达式),那么分配了内存空间后在进入函数体之前给数据成员赋值，就是说初始化这个数据成员此时函数体还未执行。 

 

必须使用成员初始化的四种情况?

  • 当初始化一个引用成员时；
  • 当初始化一个常量成员时；博客搬家
  • 当调用一个基类的构造函数，而它拥有一组参数时；
  • 当调用一个成员类的构造函数，而它拥有一组参数时；
    成员初始化列表做了什么?
  • 编译器会一一操作初始化列表，以适当的顺序在构造函数之内安插初始化操作，并且在任何显示用户代码之前；
  • list中的项目顺序是由类中的成员声明顺序决定的，不是由初始化列表的顺序决定的；

 

2.类的成员函数

 

默认构造函数

  1. C++ 默认构造函数是对类中的参数提供默认值的构造函数，一般情况下，是一个没有参数值的空函数，也可以提供一些的默认值的构造函数，如果用户没有定义构造函数，那么编译器会给类提供一个默认的构造函数，但是只要用户自定义了任意一个构造函数，那么编译器就不会提供默认的构造函数，这种情况下，容易编译报错，所以正确的写法就是用户在定义构造函数的时候，也需要添加一个默认的构造函数，这样就不会造成编译报错。
  2.  
  3. #include <iostream>
  4. using namespace std;
  5. class Point{
  6.     public:
  7.         Point():x(0), y(0){                          //默认构造函数
  8.             cout<<"Default Constructor called."<<endl;
  9.         }
  10.         //Point(){};
  11.         Point(int x, int y):x(x), y(y){              //有形参的构造函数
  12.             cout<<"Constructor called."<<endl;
  13.         }
  14.         ~Point(){
  15.             cout<<"Destructor called."<<endl;
  16.         }
  17.         int getX() const {return x;}
  18.         int getY() const {return y;}
  19.         void move(int newX, int newY){
  20.             x=newX;
  21.             y=newY;
  22.         }
  23.     private:
  24.         int x,y;
  25. }; 
  26.  
  27. int main(){
  28.     cout<<"Step one: "<<endl;
  29.     Point();                      //调用默认构造函数
  30.     cout<<"Step two: "<<endl;
  31.     Point(1,2);                   //调用有形参的构造函数
  32.     return 0;
  33. }

 

一个派生类构造函数的执行顺序如下：

 

 

什么情况会自动生成默认构造函数？

 

  • 虚拟基类的构造函数（多个虚拟基类则按照继承的顺序执行构造函数）。
  • 基类的构造函数（多个普通基类也按照继承的顺序执行构造函数）。
  • 对象的vptr被初始化；
  • 成员对象构造
  • 如果有成员初始化列表，将在构造函数体内扩展开来，这必须在vptr被设定之后才做；
  • 派生类自己的构造函数。

 

何时需要合成构造函数

  1. 带有默认构造函数的类成员对象，如果一个类没有任何构造函数，但它含有一个成员对象，而后者有默认构造函数，那么编译器就为该类合成出一个默认构造函数。不过这个合成操作只有在构造函数真正被需要的时候才会发生；如果一个类A含有多个成员类对象的话，那么类A的每一个构造函数必须调用每一个成员对象的默认构造函数而且必须按照类对象在类A中的声明顺序进行；
  2. 带有默认构造函数的基类，如果一个没有任务构造函数的派生类派生自一个带有默认构造函数基类，那么该派生类会合成一个构造函数调用上一层基类的默认构造函数；
  3. 带有一个虚函数的类
  4. 带有一个虚基类的类
  5. 合成的默认构造函数中，只有基类子对象和成员类对象会被初始化。所有其他的非静态数据成员都不会被初始化。
  1. 如果一个类没有任何构造函数，但他含有一个成员对象，该成员对象含有默认构造函数，那么编译器就为该类合成一个默认构造函数，因为不合成一个默认构造函数那么该成员对象的构造函数不能调用；
  2. 没有任何构造函数的类派生自一个带有默认构造函数的基类，那么需要为该派生类合成一个构造函数，只有这样基类的构造函数才能被调用；
  3. 带有虚函数的类，虚函数的引入需要进入虚表，指向虚表的指针，该指针是在构造函数中初始化的，所以没有构造函数的话该指针无法被初始化；
  4. 带有一个虚基类的类
    注意
    并不是任何没有构造函数的类都会合成一个构造函数,编译器合成出来的构造函数并不会显示设定类内的每一个成员变量

 一个C++空类默认产生哪些函数?

构造函数和析构函数调用时机？

全局范围中的对象：构造函数在所有函数调用之前执行，在主函数执行完调用析构函数。

局部自动对象：建立对象时调用构造函数，离开作用域时调用析构函数。

动态分配的对象：建立对象时调用构造函数，调用释放时调用析构函数。

静态局部变量对象：建立时调用一次构造函数，主函数结束时调用析构函数。

 

  1. 10.lambda函数
  2. 1)利用lambda表达式可以编写内嵌的匿名函数，用以替换独立函数或者函数对象；
  3. 2)每当你定义一个lambda表达式后，编译器会自动生成一个匿名类（这个类当然重载了()运算符），我们称为闭包类型（closure type）。那么在运行时，这个lambda表达式就会返回一个匿名的闭包实例，其实一个右值。所以，我们上面的lambda表达式的结果就是一个个闭包。闭包的一个强大之处是其可以通过传值或者引用的方式捕捉其封装作用域内的变量，前面的方括号就是用来定义捕捉模式以及变量，我们又将其称为lambda捕捉块。
  4. 3)lambda表达式的语法定义如下：
  5. [capture] （parameters） mutable ->return-type {statement};
  6. 4)lambda必须使用尾置返回来指定返回类型，可以忽略参数列表和返回值，但必须永远包含捕获列表和函数体；
  7. this指针是什么？
  8.  
  9. this指针是类的指针，指向对象的首地址。
  10.  
  11. this指针只能在成员函数中使用，在全局函数、静态成员函数中都不能用this。
  12.  
  13. this指针只有在成员函数中才有定义，且存储位置会因编译器不同有不同存储位置。
  14.  
  15. 类模板是什么？
  16.  
  17. 用于解决多个功能相同、数据类型不同的类需要重复定义的问题。
  18.  
  19. 在建立类时候使用template及任意类型标识符T，之后在建立类对象时，会指定实际的类型，这样才会是一个实际的对象。
  20.  
  21. 类模板是对一批仅数据成员类型不同的类的抽象，只要为这一批类创建一个类模板，即给出一套程序代码，就可以用来生成具体的类。
  22. 11.cout和printf有什么区别？
  23. cout<<是一个函数，cout<<后可以跟不同的类型是因为cout<<已存在针对各种类型数据的重载，所以会自动识别数据的类型。输出过程会首先将输出字符放入缓冲区，然后输出到屏幕。
  24. cout是有缓冲输出:
  25. cout < < "abc " < <endl;
  26. 或cout < < "abc\n ";cout < <flush; 这两个才是一样的.
  27. endl相当于输出回车后，再强迫缓冲输出。
  28. flush立即强迫缓冲输出。
  29. printf是无缓冲输出。有输出时立即输出
  30. 12.静态成员与普通成员的区别
  31. 1)生命周期
  32. 静态成员变量从类被加载开始到类被卸载，一直存在；
  33. 普通成员变量只有在类创建对象后才开始存在，对象结束，它的生命期结束；
  34. 2)共享方式
  35. 静态成员变量是全类共享；普通成员变量是每个对象单独享用的；
  36. 3)定义位置
  37. 普通成员变量存储在栈或堆中，而静态成员变量存储在静态全局区；
  38. 4)初始化位置
  39. 普通成员变量在类中初始化；静态成员变量在类外初始化；
  40. 5)默认实参
  41. 1.可以使用静态成员变量作为默认实参
  42.  
  43.  
  44.  
  45. 13.在成员函数中调用delete this会出现什么问题？对象还可以使用吗？
  46. 1.在类对象的内存空间中，只有数据成员和虚函数表指针，并不包含代码内容，类的成员函数单独放在代码段中。在调用成员函数时，隐含传递一个this指针，让成员函数知道当前是哪个对象在调用它。当调用delete this时，类对象的内存空间被释放。在delete this之后进行的其他任何函数调用，只要不涉及到this指针的内容，都能够正常运行。一旦涉及到this指针，如操作数据成员，调用虚函数等，就会出现不可预期的问题。
  47. 2.为什么是不可预期的问题？
  48. delete this之后不是释放了类对象的内存空间了么，那么这段内存应该已经还给系统，不再属于这个进程。照这个逻辑来看，应该发生指针错误，无访问权限之类的令系统崩溃的问题才对啊？这个问题牵涉到操作系统的内存管理策略。delete this释放了类对象的内存空间，但是内存空间却并不是马上被回收到系统中，可能是缓冲或者其他什么原因，导致这段内存空间暂时并没有被系统收回。此时这段内存是可以访问的，你可以加上100，加上200，但是其中的值却是不确定的。当你获取数据成员，可能得到的是一串很长的未初始化的随机数；访问虚函数表，指针无效的可能性非常高，造成系统崩溃。
  49. 1)
  50.  
  51.  
  52. 1)
  53. 14.空类的大小是多少？为什么？
  54. 1)C++空类的大小不为0，不同编译器设置不一样，vs设置为1；
  55. 2)C++标准指出，不允许一个对象（当然包括类对象）的大小为0，不同的对象不能具有相同的地址；
  56. 3)带有虚函数的C++类大小不为1，因为每一个对象会有一个vptr指向虚函数表，具体大小根据指针大小确定；
  57. 1.C++中要求对于类的每个实例都必须有独一无二的地址,那么编译器自动为空类分配一个字节大小，这样便保证了每个实例均有独一无二的内存地址。
  58.  
  59.  
  60.  
  61.  
  62. 15.为什么会有大端小端，htol这一类函数的作用
  63. 1)这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一个字节，一个字节为 8bit。但是在C语言中除了8bit的char之外，还有16bit的short型，32bit的long型（要看具体的编译器），另外，对于位数大于 8位的处理器，例如16位或者32位的处理器，由于寄存器宽度大于一个字节，那么必然存在着一个如何将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。例如一个16bit的short型x，在内存中的地址为0x0010，x的值为0x1122，那么0x11为高字节，0x22为低字节。对于 大端模式，就将0x11放在低地址中，即0x0010中，0x22放在高地址中，即0x0011中。小端模式，刚好相反。我们常用的X86结构是小端模式，而KEIL C51则为大端模式。很多的ARM，DSP都为小端模式。有些ARM处理器还可以由硬件来选择是大端模式还是小端模式。
  64. 16.this指针调用成员变量时，堆栈会发生什么变化？
  65. 1)当在类的非静态成员函数访问类的非静态成员时，编译器会自动将对象的地址传给作为隐含参数传递给函数，这个隐含参数就是this指针。即使你并没有写this指针，编译器在链接时也会加上this的，对各成员的访问都是通过this的。例如你建立了类的多个对象时，在调用类的成员函数时，你并不知道具体是哪个对象在调用，此时你可以通过查看this指针来查看具体是哪个对象在调用。This指针首先入栈，然后成员函数的参数从右向左进行入栈，最后函数返回地址入栈。
  66.  
  67. 17.设计一个类计算子类的个数
  68. 1.为类设计一个static静态变量count作为计数器；
  69. 2.类定义结束后初始化count;
  70. 3.在构造函数中对count进行+1;
  71. 4.设计拷贝构造函数，在进行拷贝构造函数中进行count +1，操作；
  72. 5.设计复制构造函数，在进行复制函数中对count+1操作；
  73. 6.在析构函数中对count进行-1；
  74. 1)
  75. 18.类对象的大小
  76. 1)类的非静态成员变量大小，静态成员不占据类的空间，成员函数也不占据类的空间大小；
  77. 2)内存对齐另外分配的空间大小，类内的数据也是需要进行内存对齐操作的；
  78. 3)虚函数的话，会在类对象插入vptr指针，加上指针大小；
  79. 4)当该该类是某类的派生类，那么派生类继承的基类部分的数据成员也会存在在派生类中的空间中，也会对派生类进行扩展。
  80. 1)
  81. 19.C++如何阻止一个类被实例化？一般在什么时候将构造函数声明为private？
  82. 1)将类定义为抽象基类或者将构造函数声明为private；
  83. 2)不允许类外部创建类对象，只能在类内部创建对象

 

 

 

拷贝构造函数

  1. 一、什么是拷贝构造函数
  2.  
  3.       首先对于普通类型的对象来说，它们之间的复制是很简单的，例如：
  4. int a=100;
  5. int b=a;
  6.  
  7.   而类对象与普通对象不同，类对象内部结构一般较为复杂，存在各种成员变量。
  8.   下面看一个类对象拷贝的简单例子。
  9.    
  10. 复制代码
  11. 复制代码
  12. #include<iostream>
  13. using namespace std;
  14. class CExample
  15. {
  16. private:
  17.     int a;
  18. public:
  19.     //构造函数
  20.     CExample(int b)
  21.     {
  22.         a=b;
  23.         printf("constructor is called\n");
  24.     }
  25.     //拷贝构造函数
  26.     CExample(const CExample & c)
  27.     {
  28.         a=c.a;
  29.         printf("copy constructor is called\n");
  30.     }
  31.     //析构函数
  32.     ~CExample()
  33.     {
  34.         cout<<"destructor is called\n";
  35.     }
  36.     void Show()
  37.     {
  38.         cout<<a<<endl;
  39.     }
  40. };
  41. int main()
  42. {
  43.     CExample A(100);
  44.     CExample B=A;
  45.     B.Show(); 
  46.     return 0;
  47. }
  48. 复制代码
  49. 复制代码
  50.    运行程序，屏幕输出100。从以上代码的运行结果可以看出，系统为对象 B 分配了内存并完成了与对象 A 的复制过程。就类对象而言，相同类型的类对象是通过拷贝构造函数来完成整个复制过程的。
  51.   
  52.  
  53.  CExample(const CExample& C)　就是我们自定义的拷贝构造函数。可见，拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它必须的一个参数是本类型的一个引用变量。
  54.  
  55. 二、拷贝构造函数的调用时机
  56.     1. 当函数的参数为类的对象时
  57.   
  58. 复制代码
  59. 复制代码
  60.   
  61. #include<iostream>
  62. using namespace std;
  63. class CExample
  64. {
  65. private:
  66.     int a;
  67. public:
  68.     CExample(int b)
  69.     {
  70.         a=b;
  71.         printf("constructor is called\n");
  72.     }
  73.     CExample(const CExample & c)
  74.     {
  75.         a=c.a;
  76.         printf("copy constructor is called\n");
  77.     }
  78.     ~CExample()
  79.     {
  80.      cout<<"destructor is called\n";
  81.     }
  82.     void Show()
  83.     {
  84.      cout<<a<<endl;
  85.     }
  86. };
  87. void g_fun(CExample c)
  88. {
  89.     cout<<"g_func"<<endl;
  90. }
  91. int main()
  92. {
  93.     CExample A(100);
  94.     CExample B=A;
  95.     B.Show(); 
  96.     g_fun(A);
  97.     return 0;
  98. }
  99. 复制代码
  100. 复制代码
  101.  
  102.  调用g_fun()时，会产生以下几个重要步骤：
  103. (1).A对象传入形参时，会先会产生一个临时变量，就叫 C 吧。
  104. (2).然后调用拷贝构造函数把A的值给C。 整个这两个步骤有点像：CExample C(A);
  105. (3).等g_fun()执行完后, 析构掉 C 对象。  
  106.  
  107.     
  108.  
  109. 2. 函数的返回值是类的对象
  110.   
  111. 复制代码
  112. 复制代码
  113. #include<iostream>
  114. using namespace std;
  115. class CExample
  116. {
  117. private:
  118.     int a;
  119. public:
  120.     //构造函数
  121.     CExample(int b)
  122.     {
  123.      a=b;
  124.         printf("constructor is called\n");
  125.     }
  126.     //拷贝构造函数
  127.     CExample(const CExample & c)
  128.     {
  129.      a=c.a;
  130.         printf("copy constructor is called\n");
  131.     }
  132.     //析构函数
  133.     ~CExample()
  134.     {
  135.      cout<<"destructor is called\n";
  136.     }
  137.     void Show()
  138.     {
  139.      cout<<a<<endl;
  140.     }
  141. };
  142. CExample g_fun()
  143. {
  144.     CExample temp(0);
  145.     return temp;
  146. }
  147. int main()
  148. {
  149.     
  150.     g_fun();
  151.     return 0;
  152. }
  153. 复制代码
  154. 复制代码
  155.  
  156.    当g_Fun()函数执行到return时，会产生以下几个重要步骤：
  157. (1). 先会产生一个临时变量，就叫XXXX吧。
  158. (2). 然后调用拷贝构造函数把temp的值给XXXX。整个这两个步骤有点像：CExample XXXX(temp);
  159. (3). 在函数执行到最后先析构temp局部变量。
  160. (4). 等g_fun()执行完后再析构掉XXXX对象。  
  161.   
  162.  
  163. 3. 对象需要通过另外一个对象进行初始化
  164. CExample A(100);
  165. CExample B=A;
  166. 三、浅拷贝与深拷贝
  167.     1. 默认拷贝构造函数
  168.    很多时候在我们都不知道拷贝构造函数的情况下，传递对象给函数参数或者函数返回对象都能很好的进行，这是因为编译器会给我们自动产生一个拷贝构造函数，这就是“默认拷贝构造函数”，这个构造函数很简单，仅仅使用“老对象”的数据成员的值对“新对象”的数据成员一一进行赋值，它一般具有以下形式：
  169. Rect::Rect(const Rect& r)
  170. {
  171.     width=r.width;
  172.     height=r.height;
  173. }
  174. 当然，以上代码不用我们编写，编译器会为我们自动生成。但是如果认为这样就可以解决对象的复制问题，那就错了，让我们来考虑以下一段代码：
  175.  
  176. 复制代码
  177. 复制代码
  178.  
  179. #include<iostream>
  180. using namespace std;
  181. class Rect
  182. {
  183. public:
  184.     Rect()
  185.     {
  186.      count++;
  187.     }
  188.     ~Rect()
  189.     {
  190.      count--;
  191.     }
  192.     static int getCount()
  193.     {
  194.      return count;
  195.     }
  196. private:
  197.     int width;
  198.     int height;
  199.     static int count;
  200. };
  201. int Rect::count=0;
  202. int main()
  203. {
  204.     Rect rect1;
  205.     cout<<"The count of Rect:"<<Rect::getCount()<<endl;
  206.     Rect rect2(rect1);
  207.     cout<<"The count of Rect:"<<Rect::getCount()<<endl;
  208.     return 0;
  209. }
  210.   
  211. 复制代码
  212. 复制代码
  213. 这段代码对前面的类，加入了一个静态成员，目的是进行计数。在主函数中，首先创建对象rect1，输出此时的对象个数，然后使用rect1复制出对象rect2，再输出此时的对象个数，按照理解，此时应该有两个对象存在，但实际程序运行时，输出的都是1，反应出只有1个对象。此外，在销毁对象时，由于会调用销毁两个对象，类的析构函数会调用两次，此时的计数器将变为负数。
  214.  
  215. 说白了，就是拷贝构造函数没有处理静态数据成员。
  216.  
  217. 出现这些问题最根本就在于在复制对象时，计数器没有递增，我们重新编写拷贝构造函数，如下：
  218.  
  219. 复制代码
  220. 复制代码
  221. #include<iostream>
  222. using namespace std;
  223. class Rect
  224. {
  225. public:
  226.     Rect()
  227.     {
  228.         count++;
  229.     }
  230.     Rect(const Rect& r)
  231.     {
  232.         width=r.width;
  233.         height=r.height;
  234.         count++;
  235.     }
  236.     ~Rect()
  237.     {
  238.         count--;
  239.     }
  240.     static int getCount()
  241.     {
  242.         return count;
  243.     }
  244. private:
  245.     int width;
  246.     int height;
  247.     static int count;
  248. };
  249. int Rect::count=0;
  250. int main()
  251. {
  252.     Rect rect1;
  253.     cout<<"The count of Rect:"<<Rect::getCount()<<endl;
  254.     Rect rect2(rect1);
  255.     cout<<"The count of Rect:"<<Rect::getCount()<<endl;
  256.     return 0;
  257. }
  258. 复制代码
  259. 复制代码
  260.  
  261.   2. 浅拷贝
  262.  
  263.     所谓浅拷贝，指的是在对象复制时，只对对象中的数据成员进行简单的赋值，默认拷贝构造函数执行的也是浅拷贝。大多情况下“浅拷贝”已经能很好地工作了，但是一旦对象存在了动态成员，那么浅拷贝就会出问题了，让我们考虑如下一段代码：
  264.  
  265.  
  266. 复制代码
  267. 复制代码
  268. #include<iostream>
  269. #include<assert.h>
  270. using namespace std;
  271. class Rect
  272. {
  273. public:
  274.     Rect()
  275.     {
  276.      p=new int(100);
  277.     }
  278.    
  279.     ~Rect()
  280.     {
  281.      assert(p!=NULL);
  282.         delete p;
  283.     }
  284. private:
  285.     int width;
  286.     int height;
  287.     int *p;
  288. };
  289. int main()
  290. {
  291.     Rect rect1;
  292.     Rect rect2(rect1);
  293.     return 0;
  294. }
  295. 复制代码
  296. 复制代码
  297.  
  298.  在这段代码运行结束之前，会出现一个运行错误。原因就在于在进行对象复制时，对于动态分配的内容没有进行正确的操作。我们来分析一下：
  299.  
  300.     在运行定义rect1对象后，由于在构造函数中有一个动态分配的语句，因此执行后的内存情况大致如下：
  301.  
  302.      
  303.   在使用rect1复制rect2时，由于执行的是浅拷贝，只是将成员的值进行赋值，这时 rect1.p = rect2.p，也即这两个指针指向了堆里的同一个空间，如下图所示：
  304.     
  305.  
  306.  当然，这不是我们所期望的结果，在销毁对象时，两个对象的析构函数将对同一个内存空间释放两次，这就是错误出现的原因。我们需要的不是两个p有相同的值，而是两个p指向的空间有相同的值，解决办法就是使用“深拷贝”。
  307.  
  308.   3. 深拷贝
  309.  
  310.   在“深拷贝”的情况下，对于对象中动态成员，就不能仅仅简单地赋值了，而应该重新动态分配空间，如上面的例子就应该按照如下的方式进行处理：
  311.  
  312.  
  313. 复制代码
  314. 复制代码
  315. #include<iostream>
  316. #include<assert.h>
  317. using namespace std;
  318. class Rect
  319. {
  320. public:
  321.     Rect()
  322.     {
  323.      p=new int(100);
  324.     }
  325.     
  326.     Rect(const Rect& r)
  327.     {
  328.      width=r.width;
  329.         height=r.height;
  330.      p=new int(100);
  331.         *p=*(r.p);
  332.     }
  333.      
  334.     ~Rect()
  335.     {
  336.      assert(p!=NULL);
  337.         delete p;
  338.     }
  339. private:
  340.     int width;
  341.     int height;
  342.     int *p;
  343. };
  344. int main()
  345. {
  346.     Rect rect1;
  347.     Rect rect2(rect1);
  348.     return 0;
  349. }
  350. 复制代码
  351. 复制代码
  352.  
  353.   此时，在完成对象的复制后，内存的一个大致情况如下：
  354.    
  355. 此时rect1的p和rect2的p各自指向一段内存空间，但它们指向的空间具有相同的内容，这就是所谓的“深拷贝”。
  356. 3. 防止默认拷贝发生
  357.  
  358.     通过对对象复制的分析，我们发现对象的复制大多在进行“值传递”时发生，这里有一个小技巧可以防止按值传递——声明一个私有拷贝构造函数。甚至不必去定义这个拷贝构造函数，这样因为拷贝构造函数是私有的，如果用户试图按值传递或函数返回该类对象，将得到一个编译错误，从而可以避免按值传递或返回对象。
  359.  
  360. 复制代码
  361. 复制代码
  362.  
  363. //防止按值传递
  364. class CExample 
  365. { 
  366. private: 
  367.     int a; 
  368.   
  369. public: 
  370.     //构造函数
  371.     CExample(int b) 
  372.     { 
  373.         a = b; 
  374.         cout<<"creat: "<<a<<endl; 
  375.     } 
  376.   
  377. private: 
  378.     //拷贝构造函数，只是声明
  379.     CExample(const CExample& C); 
  380.   
  381. public: 
  382.     ~CExample() 
  383.     { 
  384.         cout<< "delete: "<<a<<endl; 
  385.     } 
  386.   
  387.     void Show () 
  388.     { 
  389.         cout<<a<<endl; 
  390.     } 
  391. }; 
  392.   
  393. //???? 
  394. void g_Fun(CExample C) 
  395. { 
  396.     cout<<"test"<<endl; 
  397. } 
  398.   
  399. int main() 
  400. { 
  401.     CExample test(1); 
  402.     //g_Fun(test);   //按值传递将出错
  403.       
  404.     return 0; 
  405. }
  406. 复制代码
  407. 复制代码
  408. 小结：
  409.     拷贝有两种：深拷贝，浅拷贝。
  410.       当出现类的等号赋值时，会调用拷贝函数，在未定义显示拷贝构造函数的情况下，系统会调用默认的拷贝函数——即浅拷贝，它能够完成成员的一一复制。当数据成员中没有指针时，浅拷贝是可行的。但当数据成员中有指针时，如果采用简单的浅拷贝，则两类中的两个指针将指向同一个地址，当对象快结束时，会调用两次析构函数，而导致指针悬挂现象。所以，这时，必须采用深拷贝。
  411.  
  412.      深拷贝与浅拷贝的区别就在于深拷贝会在堆内存中另外申请空间来储存数据，从而也就解决了指针悬挂的问题。简而言之，当数据成员中有指针时，必须要用深拷贝。
  413.  
  414.  
  415. 四、有关问题
  416.    1.为什么拷贝构造函数必须是引用传递，不能是值传递？
  417.      简单的回答是为了防止递归引用。
  418.           具体一些可以这么讲：
  419.     当 一个对象需要以值方式传递时，编译器会生成代码调用它的拷贝构造函数以生成一个复本。如果类A的拷贝构造函数是以值方式传递一个类A对象作为参数的话，当 需要调用类A的拷贝构造函数时，需要以值方式传进一个A的对象作为实参； 而以值方式传递需要调用类A的拷贝构造函数；结果就是调用类A的拷贝构造函数导 致又一次调用类A的拷贝构造函数，这就是一个无限递归。
  420.     
  421.    2. 拷贝构造函数的作用。     
  422.            作用就是用来复制对象的，在使用这个对象的实例来初始化这个对象的一个新的实例。
  423.  
  424.      3.参数传递过程到底发生了什么？
  425.       将地址传递和值传递统一起来，归根结底还是传递的是"值"(地址也是值，只不过通过它可以找到另一个值)！
  426.       i)值传递:
  427.          对于内置数据类型的传递时，直接赋值拷贝给形参(注意形参是函数内局部变量)；
  428.          对于类类型的传递时，需要首先调用该类的拷贝构造函数来初始化形参(局部对象)；如void foo(class_type obj_local){}, 如果调用foo(obj);  首先class_type obj_local(obj) ,这样就定义了局部变量obj_local供函数内部使用
  429.      ii)引用传递:
  430.         无论对内置类型还是类类型，传递引用或指针最终都是传递的地址值！而地址总是指针类型(属于简单类型), 显然参数传递时，按简单类型的赋值拷贝，而不会有拷贝构造函数的调用(对于类类型).
  431.  
  432.    4. 在类中有指针数据成员时，拷贝构造函数的使用？
  433.         如果不显式声明拷贝构造函数的时候，编译器也会生成一个默认的拷贝构造函数，而且在一般的情况下运行的也很好。但是在遇到类有指针数据成员时就出现问题 了：因为默认的拷贝构造函数是按成员拷贝构造，这导致了两个不同的指针(如ptr1=ptr2)指向了相同的内存。当一个实例销毁时，调用析构函数 free(ptr1)释放了这段内存，那么剩下的一个实例的指针ptr2就无效了，在被销毁的时候free(ptr2)就会出现错误了, 这相当于重复释放一块内存两次。这种情况必须显式声明并实现自己的拷贝构造函数，来为新的实例的指针分配新的内存。
  434.  
  435. 问题1和2回答了为什么拷贝构造函数使用值传递会产生无限递归调用的问题；
  436. 问题3回答了回答了在类中有指针数据成员时，拷贝构造函数使用值传递等于白显式定义了拷贝构造函数，因为默认的拷贝构造函数就是这么干的。
  437.  
  438.   5. 拷贝构造函数里能调用private成员变量吗?
  439. 解答：这个问题是在网上见的，当时一下子有点晕。其时从名子我们就知道拷贝构造函数其时就是一个特殊的构造函数，操作的还是自己类的成员变量，所以不受private的限制。
  440.  
  441.  6. 以下函数哪个是拷贝构造函数,为什么?
  442.   
  443. X::X(const X&);   //拷贝构造函数
  444. X::X(X); 
  445. X::X(X&, int a=1);   //拷贝构造函数
  446. X::X(X&, int a=1, int b=2);  //拷贝构造函数
  447.    解答：对于一个类X, 如果一个构造函数的第一个参数是下列之一:
  448.    a) X&
  449.    b) const X&
  450.    c) volatile X&
  451.    d) const volatile X&
  452.    且没有其他参数或其他参数都有默认值,那么这个函数是拷贝构造函数.
  453.  
  454.   7. 一个类中可以存在多于一个的拷贝构造函数吗?
  455.    解答：类中可以存在超过一个拷贝构造函数。
  456.   
  457. class X { 
  458. public: 
  459.   X(const X&); // const 的拷贝构造 
  460.   X(X&); // 非const的拷贝构造 
  461. };
  462.  
  463.   注意,如果一个类中只存在一个参数为 X& 的拷贝构造函数,那么就不能使用const X或volatile X的对象实行拷贝初始化.
  464.   如果一个类中没有定义拷贝构造函数,那么编译器会自动产生一个默认的拷贝构造函数。
  465.   这个默认的参数可能为 X::X(const X&)或 X::X(X&),由编译器根据上下文决定选择哪一个。
  466.  
  467.   8.什么情况下必须定义拷贝构造函数？
  468.   A3：当类的对象用于函数值传递时（值参数，返回类对象），拷贝构造函数会被调用。如果对象复制并非简单的值拷贝，那就必须定义拷贝构造函数。例如大的堆       栈数据拷贝。如果定义了拷贝构造函数，那也必须重载赋值操作符。
  469. 9.何时需要合成复制构造函数
  470. 有三种情况会以一个对象的内容作为另一个对象的初值：
  471. 1)对一个对象做显示的初始化操作，X xx = x;
  472. 2)当对象被当做参数交给某个函数时；
  473. 3)当函数传回一个类对象时；
  474.  
  475. 1)如果一个类没有拷贝构造函数，但是含有一个类类型的成员变量，该类型含有拷贝构造函数，此时编译器会为该类合成一个拷贝构造函数；
  476. 2)如果一个类没有拷贝构造函数，但是该类继承自含有拷贝构造函数的基类，此时编译器会为该类合成一个拷贝构造函数；
  477. 3)如果一个类没有拷贝构造函数，但是该类声明或继承了虚函数，此时编译器会为该类合成一个拷贝构造函数；
  478. 4)如果一个类没有拷贝构造函数，但是该类含有虚基类，此时编译器会为该类合成一个拷贝构造函数；
  479. 10.如何禁止自动生成拷贝构造函数？ 
  480. 1)为了阻止编译器默认生成拷贝构造函数和拷贝赋值函数，我们需要手动去重写这两个函数，某些情况下，为了避免调用拷贝构造函数和拷贝赋值函数，我们需要将他们设置成private，防止被调用。
  481. 2)类的成员函数和friend函数还是可以调用private函数，如果这个private函数只声明不定义，则会产生一个连接错误；
  482. 3)针对上述两种情况，我们可以定一个base类，在base类中将拷贝构造函数和拷贝赋值函数设置成private,那么派生类中编译器将不会自动生成这两个函数，且由于base类中该函数是私有的，因此，派生类将阻止编译器执行相关的操作。
  483. 11.拷贝构造函数和赋值运算符重载的区别？
  484.  
  485. 拷贝构造函数是函数，赋值运算符是运算符重载。
  486.  
  487. 拷贝构造函数会生成新的类对象，赋值运算符不能。
  488.  
  489. 拷贝构造函数是直接构造一个新的类对象，所以在初始化对象前不需要检查源对象和新建对象是否相同；赋值运算符需要上述操作并提供两套不同的复制策略，另外赋值运算符中如果原来的对象有内存分配则需要先把内存释放掉。
  490.  
  491. 形参传递是调用拷贝构造函数（调用的被赋值对象的拷贝构造函数），但并不是所有出现"="的地方都是使用赋值运算符，如下：
  492.  
  493.   Student s;
  494.   Student s1 = s;    // 调用拷贝构造函数
  495.   Student s2;
  496.   s2 = s;    // 赋值运算符操作
  497. 注：类中有指针变量时要重写析构函数、拷贝构造函数和赋值运算符

 

移动构造函数

  1. 1)有时候我们会遇到这样一种情况，我们用对象a初始化对象b后对象a我们就不在使用了，但是对象a的空间还在呀（在析构之前），既然拷贝构造函数，实际上就是把a对象的内容复制一份到b中，那么为什么我们不能直接使用a的空间呢？这样就避免了新的空间的分配，大大降低了构造的成本。这就是移动构造函数设计的初衷；
  2. 2)拷贝构造函数中，对于指针，我们一定要采用深层复制，而移动构造函数中，对于指针，我们采用浅层复制；
  3. 3)C++引入了移动构造函数，专门处理这种，用a初始化b后，就将a析构的情况；
  4. 4)与拷贝类似，移动也使用一个对象的值设置另一个对象的值。但是，又与拷贝不同的是，移动实现的是对象值真实的转移（源对象到目的对象）：源对象将丢失其内容，其内容将被目的对象占有。移动操作的发生的时候，是当移动值的对象是未命名的对象的时候。这里未命名的对象就是那些临时变量，甚至都不会有名称。典型的未命名对象就是函数的返回值或者类型转换的对象。使用临时对象的值初始化另一个对象值，不会要求对对象的复制：因为临时对象不会有其它使用，因而，它的值可以被移动到目的对象。做到这些，就要使用移动构造函数和移动赋值：当使用一个临时变量对象进行构造初始化的时候，调用移动构造函数。类似的，使用未命名的变量的值赋给一个对象时，调用移动赋值操作；
  5. 5)
  6. Example6 (Example6&& x) : ptr(x.ptr) 
  7.     {
  8.         x.ptr = nullptr;
  9.     }
  10.     // move assignment
  11.     Example6& operator= (Example6&& x) 
  12.     {
  13.         delete ptr; 
  14.         ptr = x.ptr;
  15.         x.ptr=nullptr;
  16.         return *this;
  17. }

 

析构函数

  1. 程序员定义的析构函数被扩展的过程？
  2. 1)析构函数函数体被执行；
  3. 2)如果class拥有成员类对象，而后者拥有析构函数，那么它们会以其声明顺序的相反顺序被调用；
  4. 3)如果对象有一个vptr，现在被重新定义
  5. 4)如果有任何直接的上一层非虚基类拥有析构函数，则它们会以声明顺序被调用；
  6. 5)如果任何虚基类拥有析构函数
  7. 析构函数的作用，如何起作用？ 
  8. 1)构造函数只是起初始化值的作用，但实例化一个对象的时候，可以通过实例去传递参数，从主函数传递到其他的函数里面，这样就使其他的函数里面有值了。规则，只要你一实例化对象，系统自动回调用一个构造函数，就是你不写，编译器也自动调用一次。 
  9. 2)析构函数与构造函数的作用相反，用于撤销对象的一些特殊任务处理，可以是释放对象分配的内存空间；特点：析构函数与构造函数同名，但该函数前面加~。 析构函数没有参数，也没有返回值，而且不能重载，在一个类中只能有一个析构函数。 当撤销对象时，编译器也会自动调用析构函数。 每一个类必须有一个析构函数，用户可以自定义析构函数，也可以是编译器自动生成默认的析构函数。一般析构函数定义为类的公有成员。
  10. 类什么时候会析构？
  11. 1)对象生命周期结束，被销毁时；
  12. 2)delete指向对象的指针时，或delete指向对象的基类类型指针，而其基类虚构函数是虚函数时；
  13. 3)对象i是对象o的成员，o的析构函数被调用时，对象i的析构函数也被调用。
  14. 3.如果在类的析构函数中调用delete this，会发生什么？
  15. 会导致堆栈溢出。原因很简单，delete的本质是“为将被释放的内存调用一个或多个析构函数，然后，释放内存”。显然，delete this会去调用本对象的析构函数，而析构函数中又调用delete this，形成无限递归，造成堆栈溢出，系统崩溃。
  16. 能否在析构函数 构造函数中抛出异常?
  17.     析构函数
  18.      1. 不要在析构函数中抛出异常！虽然C++并不禁止析构函数抛出异常，但这样会导致程序过早结束或出现不明确的行为。
  19.      2. 如果某个操作可能会抛出异常，class应提供一个普通函数（而非析构函数），来执行该操作。目的是给客户一个处理错误的机会。
  20.      3. 如果析构函数中异常非抛不可，那就用try catch来将异常吞下，但这样方法并不好，我们提倡有错早些报出来。
  21. 构造函数
  22.      总结如下：
  23.      1. 构造函数中抛出异常，会导致析构函数不能被调用，但对象本身已申请到的内存资源会被系统释放（已申请到资源的内部成员变量会被系统依次逆序调用其析构函数）。
  24.      2. 因为析构函数不能被调用，所以可能会造成内存泄露或系统资源未被释放。
  25.      3. 构造函数中可以抛出异常，但必须保证在构造函数抛出异常之前，把系统资源释放掉，防止内存泄露。（如何保证？？？使用auto_ptr？？？）

 

 

静态的成员函数

 

静态成员函数

　　与静态数据成员一样，我们也可以创建一个静态成员函数，它为类的全部服务而不是为某一个类的具体对象服务。静态成员函数与静态数据成员一样，都是类的内部实现，属于类定义的一部分。普通的成员函数一般都隐含了一个this指针，this指针指向类的对象本身，因为普通成员函数总是具体的属于某个类的具体对象的。通常情况下，this是缺省的。如函数fn()实际上是this->fn()。但是与普通函数相比，静态成员函数由于不是与任何的对象相联系，因此它不具有this指针。从这个意义上讲，它无法访问属于类对象的非静态数据成员，也无法访问非静态成员函数，它只能调用其余的静态成员函数。下面举个静态成员函数的例子。

复制代码

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. class Myclass
  5. {
  6. private:
  7.     int a , b , c;
  8.     static int sum;  //声明静态数据成员
  9. public:
  10.     Myclass(int a , int b , int c);
  11.     static void GetSum();  //声明静态成员函数
  12. };
  13.  
  14. int Myclass::sum = 0;   //定义并初始化静态数据成员
  15.  
  16. Myclass::Myclass(int a , int b , int c)
  17. {
  18.     this->a = a;
  19.     this->b = b;
  20.     this->c = c;
  21.     sum += a+b+c;    //非静态成员函数可以访问静态数据成员
  22. }
  23. void Myclass::GetSum()    //静态成员函数的实现
  24. {
  25.     //cout<<a<<endl;    //错误代码，a是非静态数据成员
  26.     cout<<"sum="<<sum<<endl;
  27. }
  28.  
  29. int main(void)
  30. {
  31.     Myclass M(1 , 2 , 3);
  32.     M.GetSum();
  33.     Myclass N(4 , 5 , 6);
  34.     N.GetSum();
  35.     Myclass::GetSum();
  36.     return 0;
  37. }

复制代码

关于静态成员函数，可以总结为以下几点：

 

 

    • 出现在类体外的函数定义不能指定关键字static；
    • 静态成员之间可以相互访问，包括静态成员函数访问静态数据成员和访问静态成员函数；
    • 非静态成员函数可以任意地访问静态成员函数和静态数据成员；
    • 静态成员函数不能访问非静态成员函数和非静态数据成员；
    • 由于没有this指针的额外开销，因此静态成员函数与类的全局函数相比速度上会有少许的增长；
    • 调用静态成员函数，可以用成员访问操作符(.)和(->)为一个类的对象或指向类对象的指针调用静态成员函数，也可以直接使用如下格式：
      ＜类名＞::＜静态成员函数名＞（＜参数表＞）
      调用类的静态成员函数。


3.类的友元

  1. 有些情况下，允许特定的非成员函数访问一个类的私有成员，同时仍阻止一般的访问，这是很方便做到的。例如被重载的操作符，如输入或输出操作符，经常需要访问类的私有数据成员。
  2.  
  3. 友元(frend)机制允许一个类将对其非公有成员的访问权授予指定的函数或者类，友元的声明以friend开始，它只能出现在类定义的内部，友元声明可以出现在类中的任何地方：友元不是授予友元关系的那个类的成员，所以它们不受其声明出现部分的访问控制影响。通常，将友元声明成组地放在类定义的开始或结尾是个好主意。
  4.  
  5. 1、友元函数
  6.      友元函数是指某些虽然不是类成员函数却能够访问类的所有成员的函数。类授予它的友元特别的访问权，这样该友元函数就能访问到类中的所有成员。
  7.  
  8. 复制代码
  9. #include <iostream>
  10.  
  11. using namespace std;
  12.  
  13. class A
  14. {
  15. public:
  16.     friend void set_show(int x, A &a);      //该函数是友元函数的声明
  17. private:
  18.     int data;
  19. };
  20.  
  21. void set_show(int x, A &a)  //友元函数定义，为了访问类A中的成员
  22. {
  23.     a.data = x;
  24.     cout << a.data << endl;
  25. }
  26. int main(void)
  27. {
  28.     class A a;
  29.  
  30.     set_show(1, a);
  31.  
  32.     return 0;
  33. }
  34. 复制代码
  35. 2、友元类
  36.         友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息（包括私有成员和保护成员）。当希望一个类可以存取另一个类的私有成员时，可以将该类声明为另一类的友元类。
  37.  
  38. 关于友元类的注意事项：
  39.  
  40. (1) 友元关系不能被继承。
  41. (2) 友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明。
  42. (3) 友元关系不具有传递性。若类B是类A的友元，类C是B的友元，类C不一定是类A的友元，同样要看类中是否有相应的申明。
  43.  
  44. 复制代码
  45. #include <iostream>
  46.  
  47. using namespace std;
  48.  
  49. class A
  50. {
  51. public:
  52.     friend class C;                         //这是友元类的声明
  53. private:
  54.     int data;
  55. };
  56.  
  57. class C             //友元类定义，为了访问类A中的成员
  58. {
  59. public:
  60.     void set_show(int x, A &a) { a.data = x; cout<<a.data<<endl;}
  61. };
  62.  
  63. int main(void)
  64. {
  65.     class A a;
  66.     class C c;
  67.  
  68.     c.set_show(1, a);
  69.  
  70.     return 0;
  71. }
  72. 复制代码
  73. 3、友元成员函数
  74.         使类B中的成员函数成为类A的友元函数，这样类B的该成员函数就可以访问类A的所有成员了。
  75.  
  76.         当用到友元成员函数时，需注意友元声明和友元定义之间的相互依赖，在该例子中，类B必须先定义，否则类A就不能将一个B的函数指定为友元。然而，只有在定义了类A之后，才能定义类B的该成员函数。更一般的讲，必须先定义包含成员函数的类，才能将成员函数设为友元。另一方面，不必预先声明类和非成员函数来将它们设为友元。
  77.  
  78. 复制代码
  79. #include <iostream>
  80.  
  81. using namespace std;
  82.  
  83. class A;    //当用到友元成员函数时，需注意友元声明与友元定义之间的互相依赖。这是类A的声明
  84. class B
  85. {
  86. public:
  87.     void set_show(int x, A &a);             //该函数是类A的友元函数
  88. };
  89.  
  90. class A
  91. {
  92. public:
  93.     friend void B::set_show(int x, A &a);   //该函数是友元成员函数的声明
  94. private:
  95.     int data;
  96.     void show() { cout << data << endl; }
  97. };
  98.  
  99. void B::set_show(int x, A &a)       //只有在定义类A后才能定义该函数，毕竟，它被设为友元是为了访问类A的成员
  100. {
  101.     a.data = x;
  102.     cout << a.data << endl;
  103. }
  104.  
  105. int main(void)
  106. {
  107.     class A a;
  108.     class B b;
  109.  
  110.     b.set_show(1, a);
  111.  
  112.     return 0;
  113. }
  114.  
  115. 友元小结：
  116.         在需要允许某些特定的非成员函数访问一个类的私有成员（及受保护成员），而同时仍阻止一般的访问的情况下，友元是可用的。
  117.  
  118. 优点：
  119.  
  120.         可以灵活地实现需要访问若干类的私有或受保护的成员才能完成的任务；
  121.         便于与其他不支持类概念的语言(如C语言、汇编等)进行混合编程；
  122.         通过使用友元函数重载可以更自然地使用C++语言的IO流库。
  123.  
  124. 缺点：
  125. 一个类将对其非公有成员的访问权限授予其他函数或者类，会破坏该类的封装性，降低该类的可靠性和可维护性。

 

  1.  为什么友元函数必须在类内部声明？
    因为编译器必须能够读取这个结构的声明以理解这个数据类型的大、行为等方面的所有规则。有一条规则在任何关系中都很重要，那就是谁可以访问我的私有部分。

 

4.union类 

  1. 介绍:
  2. 　　共用体，也叫联合体，在一个“联合”内可以定义多种不同的数据类型， 一个被说明为该“联合”类型的变量中，允许装入该“联合”所定义的任何一种数据，这些数据共享同一段内存，以达到节省空间的目的。union变量所占用的内存长度等于最长的成员的内存长度。
  3.  
  4.  
  5.  
  6. 比较:
  7.  
  8. 先看一个关于struct的例子：
  9.  
  10. struct student
  11. {
  12.      char mark;
  13.      long num;
  14.      float score;
  15. };
  16. 其struct的内存结构如下，sizeof(struct student)的值为12bytes。
  17.  
  18.  
  19. 下面是关于union的例子：
  20.  
  21. union test
  22. {
  23.      char mark;
  24.      long num;
  25.      float score;
  26. };
  27. sizeof(union test)的值为4。因为共用体将一个char类型的mark、一个long类型的num变量和一个float类型的score变量存放在同一个地址开始的内存单元中，而char类型和long类型所占的内存字节数是不一样的，但是在union中都是从同一个地址存放的，也就是使用的覆盖技术，这三个变量互相覆盖，而这种使几个不同的变量共占同一段内存的结构，称为“共用体”类型的结构。其union类型的结构如下：
  28. 果冻想 | 一个原创文章分享网站
  29.  
  30. 因union中的所有成员起始地址都是一样的，所以&a.mark、&a.num和&a.score的值都是一样的。
  31.  
  32.  
  33.  
  34. 不能如下使用：
  35.  
  36. union test a;
  37. printf("%d", a); //错误
  38. 由于a的存储区有好几种类型，分别占不同长度的存储区，仅写共用体变量名a，这样使编译器无法确定究竟输出的哪一个成员的值。
  39.  
  40. printf("%d", a.mark);  //正确
  41.  
  42. 应用:
  43. 测试大小端
  44.  
  45. union的一个用法就是可以用来测试CPU是大端模式还是小端模式：
  46.  
  47. 复制代码
  48. #include <iostream>
  49. using namespace std;
  50.  
  51. void checkCPU()
  52. {
  53.     union MyUnion{
  54.         int a;
  55.         char c;
  56.     }test;
  57.     test.a = 1;
  58.     if (test.c == 1)
  59.         cout << "little endian" <<endl;
  60.     else cout << "big endian" <<endl;
  61. }
  62.  
  63. int main()
  64. {
  65.     checkCPU();
  66.     return 0;
  67. }

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/233687
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号