C++中的零散重要知识点

（一）：类相关

1. static 在类中的关键是用
   在类中的静态变量除了整型，枚举类型（枚举也是以整型存储的）的const类型可以在类中初始化。其他的都不能在类中初始化。（注意还必须是const类型才能）如果不是整型或枚举的const类型，那么都要在类外初始化。如：
   

   class A
   {
       static int a;
   };
   
   int A::a=1;

   
   其中类的静态成员初始化不受访问权限的控制。但以后的数据改变收到相应的访问权限限制。而且需要重点指明的是，其实类A成员a真正被编译器认为是定义的地方是其类外的的初始化。所以可以存在这样的静态数组声明：
   

   class A
   {
       static int line[];
   }
   
   int A::line[]={1,2,3};

   
   在类中可以指明大小，而在其初始化出指出。这也正是MFC类声明的消息网络建立的宏所采用的技术。
   

   #define DECLARE_MESSAGE_MAP()\
   static AFC_MSGMAP_ENTRY _messageEntries[];//我断章取义只写一部分。

   
   定义一个未知长度的消息入口结构体声明。而在cpp的宏实现完成相应初始化。
   另外类的引用数据成员只能通过构造函数的初始化列表进行初始化，因为引用数据成员必须在创建的时候初始化，而初始化列表正是创建成员变量刚完成的时候。
   
   
2. 类对象初始化
   类声明时用等号赋值，调用相应的单参数构造函数。
   
   
3. 没有成员变量的类大小
   如果我们申明一个纯空的类，那么这个类的大小是4。因为编译器会为这个类添加一个字节的变量，以使得这个类对象在内存中有唯一地址。但是不是没有成员变量就是空类了呢？这经常会引起误会，其实没有成员变量也可能会有类大小，那就是虚函数表指针。所以当一个类没有成员变量，但有虚函数时，不要以为其大小是8（一个虚表指针，一个编译器给的一个字节变量），而应该是4（仅有一个续表指针）。
   
   
4. 类对象声明
   有一种极其奇怪的类对象声明那就是构造函数加变量名。
   

   class A
   {
        int a;
   public:
       A():a(0){}
       A(int b):a(b){}
       void Show() const {cout<<a<<endl;}
   };

   
   一般声明：A a;
   奇怪声明：A(a);
   
   奇怪声明只限于单行单语句形式。所以下面的语句不是声明a，而是用a构造一个b。
   A b=A(a);//这是构造b。
   
   没有什么好讲，就和怎么声明变量一样，C++有这么一个语法。所以完全可以
   
   A(a);
   a.Show();
   
   
5. 基类的构造和析构函数中一定不要直接或间接的调用的虚函数。
   因为在基类构造函数中派生类还没构造出来，所以此时对象的类型可以认为是基类类型，所有与类型相关的东西统统不管用了，包括类型鉴别和虚函数等。同理在析构函数中也一样，因为析构是从派生类逐渐往上到基类，所以到基类析构时调用虚函数已经没用了，派生类的部分已经失去作用了。虚函数等东西也肯定功能全都丧失！
   
   所以也有人说不要在任何类的构造函数和析构函数中使用虚函数。
   
   
6. 基类指针调用一个派生类中虚函数（此函数再基类中是非虚函数），最终会调用基类的非虚函数
   
   

   class A
   {
   public:
   void Test()
   {
   cout<< "A::Test" << endl;
   }
   };
   
   class B : public A
   {
   public:
   virtual void Test()
   {
   cout<< "B::Test" << endl;
   }
   };
   
   A* pA = new B();
   pA->Test();

   因为这个在编译阶段就已经决定了，编译器发现A类中这个函数是非虚函数，所以根本不会查虚表。
   
   

7. 虚函数完成运行时的类函数多态行为

   但是我们想这样一个问题？

   如果我们想我们的类层次结构实现一个函数多态，那么我们就会想着为我们类层次结构中的基类添加虚函数，然后派生类依次重写。

   但是不是只有直接调用虚函数才能实现多态行为呢？

    

   别忘了，我们函数之间是可以相互调用的，你也看到我说的是直接。所以，我们可以通过基类一个普通函数，让此普通函数调用虚函数，实现派生类直接调用基类普通函数实现多态。这些东西说起来很简单。但实际相灵活运用，并且用的恰到好处，那可是需要很高的水平啊。其实以上提的这两种方法本质都是利用了虚函数的多态行为。但是后一种也时常在实际的使用，而初学者也经常会误会，搞不懂其中的玄机。

    

   类切割注意点：

   class A
   {
   public:
    A(){cout<<"A's default construction is invoked!"<<endl;}
    ~A(){cout<<"A's destruction is invoked!"<<endl;}
    A( const A& rhs ){cout<<"A's copy construction is invoked!"<<endl;}
    virtual void Show() const{cout<<"A's Show"<<endl;}
   };
   
   class B:public A
   {
   public:
    B(){cout<<"B's construction is invoked!"<<endl;}
    ~B(){cout<<"B's destruction is invoked!"<<endl;}
    virtual void Show() const {cout<<"B's Show"<<endl;}
   };
   
   main()
   {
       B b;
       ((A)b).Show();
   }

   
   

   其输出时什么呢？

    

   答案是：

   A's default construction is invoked!
   B's construction is invoked!
   A's copy construction is invoked!
   A's Show
   A's destruction is invoked!
   B's destruction is invoked!
   A's destruction is invoked!
   

    

   原因是：((A)b)是C++重要的对象切割，这种切割会把b对象产生临时A类对象。是一个全新的对象，所以调用的虚函数是A类的。

    

   如果在main()

   {

       B b;

       ((A&)b).Show();

   }

   其输出时什么呢？

    

   答案是：

   A's default construction is invoked!
   B's construction is invoked!
   B's Show
   B's destruction is invoked!
   A's destruction is invoked!

   原因是：((A&)b)相当于把b传递给A&的一个匿名对象，由于引用所以没有创建新对象，还是原来对象的另一个别名，同时具有指针的多态性质。

    

   另外容易混淆的是：在类函数中以类作用域符号调用虚函数方式将不会有多态性之，而是单纯的调用对应类的对应函数。切记！

   
   
   
8. 类中同一段（如public,protected,private）中的变量在内存中的顺序与书写顺序一致，但不同段之间的变量的内存相对顺序是未定义的。（Inside C++ Model一书中是这么说的，未曾验证）
   
   
9. 虚继承
   1.虚继承是指使用virtual关键字去继承某类，主要是确保在多重继承中避免基类存在两份。
   
   

       class A { public: int a; };
       class B : public virtual A   { public: int b; };
       class C : public virtual A   { public: int c; };
       class D : public B, public C { public: int d; };
       
       D d;
       int iSize = sizeof( d );

   
   上述代码中：iSize = 24(在Mac机器上做的测试，最近转了ios，一直用Mac）
   
   实现机制是，在高层的派生类中（d），只存留一份A。而在B和C中只存留A的相关指针（编译器编译时添加的，指针的值并不是d中的a的地址，而是类级别的地址，也就是说D的不同对象中这个指针的地址是一致的。具体实现目前不清楚）。详细讲解见《Inside the C++ object Model》
   
   2.有虚函数，有数据成员的的虚基类
   

   class AX
       {
       public:
           AX(){std::cout<<"A's default construction is invoked!"<<std::endl;}
           ~AX(){std::cout<<"A's destruction is invoked!"<<std::endl;}
           virtual void Test() {}
           int a;
       };
       
       class BX:public virtual AX
       {
       public:
           BX(){std::cout<<"B's construction is invoked!"<<std::endl;}
           ~BX(){std::cout<<"B's destruction is invoked!"<<std::endl;}
       };
   
       int iSizeBX = sizeof( BX );

   
   
   此时的iSizeBX是多少呢？答案是：12。C++标准要求虚基类的直接派生类，