类学习小结

1.派生类的构造函数执行次序

（1）调用基类构造函数，调用顺序按照他们被继承时声明的顺序（从左到右）。

（2）调用内嵌成员对象的构造函数，调用顺序按照他们在类中声明的顺序；

（3）派生类的构造函数体中的内容。

2.构造函数初始化式

（1）有时需要构造函数初始化列表。

如果没有为类成员提供初始化式，编译器就会隐式地使用成员类型的默认构造函数，如果那个类没有默认构造函数，则会调用失败。

注意：因为内置类型的成员是不进行隐式初始化的，所以对这些成员进行初始化或者赋值都无关重要，但是有两个例外！！就是Const对象和引用类型的对象。！

例如：

Class ConstRef
{
   public:
       ConstRef(int ii);
   private:
       int i;
       const int ci;
       int &ri;

};

//Error！！ri没有初始化
ConstRef::ConstRef(int ii)
{
        i = ii;  //OK!!
        ci = ii;  //error!,不能对常量赋值
         ri = i;//ri根本有绑定到对象上！
}

正确方式应改为：

ConstRef::ConstRef(int ii)：i(ii),ci(i),ri(ii){}

所以，必须对任何const或引用类型成员以及没有默认构造函数的类类型的任何成员使用初始化式！

2.成员初始化的次序

一般来说，初始化的次序常常无关重要，然而，如果一个成员根据其他成员初始化，则成员初始化的次序就至关重要了。

考虑下面的类：

 class X
 {
   int i;
   int j;
 public :
      //运行时错误！i在j之前初始化！
     X(int val):j(val),i(j){}
 }

这种情况下，看起来好像挺合理，首先用val初始化j，再用j初始化i，但是实际上i是第一个被初始化的！！所以这里是用没初始化的j来初始化i是错哦！

3.初始化式可以是任意表达式。

一个初始化式可以是任意复杂的表达式。（这里没什么好说，就这么多）

4.隐式类类型转换

可以用单个实参来调用的构造函数来定义了从形参类型到该类类型的一个隐式转换！

让我们看看以下具有两个构造函数的类：

 1 class sale
 2 {
 3      public:
 4          sale(const std::string &book =- ""): isbn(book),sold(0){}
 5          sale(std::istream &is);
 6          bool same_isbn(sale &sa);
 7      private:
 8          std::string isbn;
 9          int sold;
 };
 //当我们写以下语句时：
 
 string book1 = "9-999";
 item.same_isbn(book1);//假设item是sale的一个对象实例
 
 //book1就会调用接受一个string的构造函数隐式地转换为一个sale对象。
 
 
 
 

那么我们该怎么抑制隐式转换呢？很简单，用explicit声明构造函数就行了，声明之后如果想转换就要显示转换了，要不就会出现错误！

5.类成员的显示初始化

尽管大多数对象可以通过运行适当的构造函数进行初始化，但是我们能不能像初始化数组一样直接显示初始化对象呢，答案是可以！但是有条件，这个条件就是这个类没有定义构造函数而且数据成员全部为public！！！！

 1 struct data
 2 {
 3      int ival；
 4       char* p；
 5 }；
 6 
 7 data vall = {0，0}；OK!
 8 
 9 data val2 = {12，“hello”}；OK!
 

这种初始化有三个缺点：

（1）要求全体数据成员未public；

（2）将初始化每个对象的数据成员的负担放在程序员身上；

（3）如果增加或删除一个成员，必须找到所有的初始化并正确更新。

未完待续~~~~~！