C++笔记： 面向对象编程进阶

[前篇]C++笔记：面向对象编程基础

转换与继承

派生类到基类到自动转换

派生类指针 ----> 基类指针 --/-> 派生类指针
派生类对象 --/-> 基类对象 --/-> 派生类对象

• 派生类对象的引用或指针可以自动转换为基类子对象的引用或指针。（因为派生类对象也是基类对象）
• 没有从基类引用或指针到派生类引用或指针的自动转换。（一个基类对象可能是也可能不是一个派生类对象的部分）
• 虽然一般可以使用派生类型的对象对基类类型的对象进行初始化或赋值，但对象转换的情况更为复杂，没有从派生类型对象到基类类型对象的直接转换。
• 可以使用派生类对象的地址对基类类型的指针进行赋值或初始化。
• 可以使用派生类型的引用或对象初始化基类类型的引用。
• 引用转换不同于转换对象
  • 将对象传给希望接受引用的函数时，引用直接绑定到该对象，虽然看起来在传递对象，实际上实参是该对象的引用，对象本身未被复制，并且转换不会在任何方面改变派生类型对象，该对象仍是派生类型对象。
  • 将派生类对象传给希望接受基类类型对象(而不是引用)的函数时，形参的类型是固定的，在编译时和运行时形参都是基类类型对象。如果用派生类型对象调用这样的函数，则该派生类对象的基类部分被复制到形参。
  • 一个是派生类对象转换为基类类型引用，一个是用派生类对象对基类对象进行初始化或赋值，理解它们之间的区别很重要。

用派生类对象对基类对象进行初始化或赋值

• 对基类对象进行初始化或赋值，实际上是在调用函数:初始化时调用构造函数，赋值时调用赋值操作符
• 用派生类对象对基类对象进行初始化或赋值时，有两种可能性。

  • 基类显式定义了将派生类型对象复制或赋值给基类对象的含义，然而这种情况并不常见。[Code1]

  • 基类一般(显式或隐式地)定义自己的复制构造函数和赋值操作符，这些成员接受一个形参，该形参是基类类型的const引用。因为存在从派生类引用到基类引用的转换，这些复制控制成员可用于从派生类对象对基类对象进行初始化或赋值。[Code2]

    • 将Bulk_item对象转换为Item_base引用，这仅仅意味着将一个Item_base引用绑定到Bulk_item对象。
    • 将该引用作为实参传给复制构造函数或赋值操作符。
    • 那些操作符使用Bulk_item的Item_base部分分别对调用构造函数或赋值的Item_base对象的成员进行初始化或赋值。
    • 一旦操作符执行完毕，对象即为Item_base。它包含Bulk_item的Item_base部分的副本，但实参的 Bulk_item部分被忽略。

派生类到基类转换到可访问性

• 像继承的成员函数一样，从派生类到基类的转换可能是也可能不是可访问的。转换是否访问取决于在派生类的派生列表中指定的访问标号。
  • 如果是public继承，则用户代码和后代类都可以使用派生类到基类的转换。
  • 如果类是使用private或protected继承派生的，则用户代码不能将派生类型对象转换为基类对象。
  • 如果是private继承，则从private继承类派生的类不能转换为基类。
  • 如果是protected继承，则后续派生类的成员可以转换为基类类型。
• 要确定到基类的转换是否可访问，可以考虑基类的public成员是否访问，如果可以，转换是可访问的，否则，转换是不可访问的。
• 无论是什么派生访问标号，派生类本身都可以访问基类的public成员，因此，派生类本身的成员和友元总是可以访问派生类到基类的转换。 
  详解

派生类到基类的转换

• 从基类到派生类的自动转换是不存在的
  • 原因在于基类对象只能是基类对象，它不能包含派生类型成员。如果允许用基类对象给派生类型对象赋值，那 么就可以试图使用该派生类对象访问不存在的成员。
• 基类指针或引用实际绑定到绑定到派生类对象时，从基类到派生类的转换也存在限制
  • 编译器在编译时无法知道特定转换在运行时实际上是安全的。编译器确定转换是否合法，只看指针或引用的静态类型
  • 如果知道从基类到派生类的转换是安全的，就可以使用static_cast强制编译器进行转换。或者，可以用 dynamic_cast申请在运行时进行。

构造函数和复制控制

• 每个派生类对象由派生类中定义的(非static)成员加上一个或多个基类子对象构成，这一事实影响着派生类型对象的构造、复制、赋值和撤销。
• 当构造、复制、赋值和撤销派生类对象时，也会构造、复制、赋值和撤销这些基类当子对象。
• 构造函数和复制控制成员不能继承，每个类定义自己的构造函数和复制控制成员。如果类不定义自己的默认构造函数和复制控制成员，就将使用合成版本。
• 只希望派生类使用的特殊构造函数，基类当构造函数应定义为protected。

派生类的构造函数

• 合成的派生类默认构造函数

  • 派生类的合成默认构造函数与非派生的构造函数只有一点不同:除了初始化派生类的数据成员之外，它还初始化派生类对象的基类部分。基类部分由基类的默认构造函数初始化。
  • 对于Bulk_item 类，合成的默认构造函数会这样执行:
    • 调用Item_base的默认构造函数，将isbn成员初始化空串，将price成员初始化为 0。
    • 用常规变量初始化规则初始化Bulk_item的成员，也就是说，qty和discount成员会是未初始化的。

• 定义默认构造函数[Code3]

  • Code3中隐式调用Item_base的默认构造函数初始化对象的基类部分，再初始化Bulk_item部分的成员并执行构造函数的函数体。
• 向基类构造函数传递实参[Code4]
  • 构造函数初始化列表为类的基类和成员提供初始值，它并不指定初始化的执行次序。首先初始化基类，然后根据声明次序初始化派生类的成员。
• 在派生类构造函数中使用默认实参。[Code5]
• 只能初始化直接基类

复制控制和继承

• 如果派生类显式定义自己的复制构造函数或赋值操作符，则该定义将完全覆盖默认定义。被继承类的复制构造函数和赋值操作符负责对基类成分以及类自己的成员进行复制或赋值。
• 如果派生类定义了自己的复制构造函数，该复制构造函数一般应显式使用基类复制构造函数初始化对象的基类部分，否则运行基类的默认构造函数，则新构造的对象将具有奇怪的配置:它的Base部分将保存默认值，而它的 Derived成员是另一对象的副本。[Code6]
• 如果派生类定义了自己的赋值操作符，则该操作符必须对基类部分进行显式赋值。[Code7]
• 析构函数的工作与复制构造函数和赋值操作符不同，派生类析构函数不负责撤销基类对象的成员。

继承情况下的类作用域

• 在继承情况下，派生类的作用域嵌套在基类作用域中。如果不能在派生类作用域中确定名字，就在外围基类作用域中查找该名字的定义。
• 对象、引用或指针的静态类型决定了对象能够完成的行为。 
  • 当静态类型和动态类型可能不同的时候，就像使用基类类型的引用或指针时可能会发生的， 静态类型仍然决定着可以使用什么成员。[Code8]
• 与基类成员同名的派生类成员将屏蔽对基类成员的直接访问。
  • 可以使用作用域操作符访问被屏蔽的基类成员，例如：Base::mem
  • 设计派生类时，只要可能，最好避免与基类成员的名字冲突。
• 基类和派生类中使用同一名字的成员函数,在派生类作用域中派生类成员将屏蔽基类成员。即使函数原型不同,基类成员也会被屏蔽。[Code9]
  • 局部作用域中声明的函数不会重载全局作用域中定义的函数,同样,派生类中定义的函数也不重载基类中定义的成员。
  • 通过派生类对象调用函数时,实参必须与派生类中定义的版本相匹配,只有在派生类根本没有定义该函数时,才考虑基类函数。
• 派生类可以重定义所继承的0个或多个版本。
  • 如果派生类重定义了重载成员,则通过派生类型只能访问派生类中重定义的那些成员。
  • 如果派生类想通过自身类型使用的重载版本,则派生类必须要么重定义所有重载版本,要么一个也不重定义。
  • 有时类需要仅仅重定义一个重载集中某些版本的行为,并且想要继承其他版本的含义,可以为重载成员提供using声明
    • 一个 using 声明只能指定一个名字,不能指定形参表,因此,为基类成员函数名称而作的using声明将该函数的所有重载实例加到派生类的作用域。将所有名字加入作用域之后,派生类只需要重定义本类型确实必 须定义的那些函数,对其他版本可以使用继承的定义。

容器与继承

• 希望使用容器(或内置数组)保存因继承而相关联的对象。但是,对象不是多态的,这一事实对将容器用于继承层次中的类型有影响。[Code10]
  • 若是基类容器则派生类会被截断，如是派生类容器则不能放入基类
  • 唯一可行的选择可能是使用容器保存对象的指针。但代价是需要用户面对管理对象和指针的问题,用户必须保证只要容器存在,被指向的对象就存在。如果对象是动态分配的,用户必须保证在容器消失时适当地释放对象。

Code

Code1：基类显式定义了将派生类型对象复制或赋值给基类对象的含义

 class Derived;
 class Base {
 public:
     Base(const Derived&);  // create a new Base from a Derived
     Base &operator=(const Derived&);  // assign from a Derived
     // ...
 };

Code2：基类一般(显式或隐式地)定义自己的复制构造函数和赋值操作符

Item_base item; // object of base type
Bulk_item bulk; // object of derived type
// ok: uses Item_base::Item_base(const Item_base&) constructor
Item_base item(bulk);  // bulk is "sliced down" to its Item_base portion
// ok: calls Item_base::operator=(const Item_base&)
item = bulk;           // bulk is "sliced down" to its Item_base portion

Code3：定义默认构造函数

class Bulk_item : public Item_base {
 public:
     Bulk_item(): min_qty(0)， discount(0.0) { }
     // as before
 };

Code4：向基类构造函数传递实参

class Bulk_item : public Item_base {
 public:
     Bulk_item(const std::string& book， double sales_price，
               std::size_t qty = 0， double disc_rate = 0.0):
                  Item_base(book， sales_price)，
                  min_qty(qty)， discount(disc_rate) { }
     // as before
  };

Code5：在派生类构造函数中使用默认实参

class Bulk_item : public Item_base {
 public:
     Bulk_item(const std::string& book = ""， double sales_price = 0.0，
               std::size_t qty = 0， double disc_rate = 0.0):
                  Item_base(book， sales_price)，
                  min_qty(qty)， discount(disc_rate) { }
     // as before
  };
//这里为每个形参提供了默认值，因此，可以用 0 至 4 个实参使用该构造函数。

Code6：定义派生类的复制构造函数，一般应显式使用基类复制构造函数初始化对象的基类部分

class Base { /* ... */ };
 class Derived: public Base {
 public:
     // Base::Base(const Base&) not invoked automatically
     Derived(const Derived& d):
          Base(d) /* other member initialization */ { /*... */ }
};
/*初始化函数 Base(d) 将派生类对象 d 转换为它的基类部分的引用，并调用基类复制构造函数。如果省略基类初始化函数，如下代码:*/
// probably incorrect definition of the Derived copy constructor
Derived(const Derived& d) /* derived member initizations */
{/* ... */ }
/*效果是运行 Base 的默认构造函数初始化对象的基类部分。假定 Derived 成员的初始化从 d 复制对应成员，则新构造的对象将具有奇怪的配置:它的 Base 部分将保存默认值，而它的 Derived 成员是另一对象的副本。*/

Code7：派生类的赋值操作符

// Base::operator=(const Base&) not invoked automatically
 Derived &Derived::operator=(const Derived &rhs)
 {
    if (this != &rhs) {
    Base::operator=(rhs); // assigns the base part
    // do whatever needed to clean up the old value in the derived part
    // assign the members from the derived
    }
    retrun *this;
}
/*基类操作符将释放左操作数中基类部分 的值，并赋以来自 rhs 的新值。该操作符执行完毕后，接着要做的是为派生类 中的成员赋值。*/

Code8：名字查找在编译时发生

/*例如，可以给 Disc_item 类增加一个 成员，该成员返回一个保存最小(或最大)数量和折扣价格的 pair 对象:*/
 class Disc_item : public Item_base {
 public:
     std::pair<size_t， double> discount_policy() const
         { return std::make_pair(quantity， discount); }
     // other members as before
 };
/*只能通过 Disc_item 类型或 Disc_item 派生类型的对象、指针或引用访问 discount_policy:*/
 Bulk_item bulk;
Bulk_item*bulkP=&bulk; //ok:staticanddynamictypesarethe same
Item_base *itemP = &bulk; // ok: static and dynamic types differ 
bulkP->discount_policy(); // ok: bulkP has type Bulk_item* 
itemP->discount_policy(); // error: itemP has type Item_base*
/*重新定义 itemP 的访问是错误的，因为基类类型的指针(引用或对象)只 能访问对象的基类部分，而在基类中没有定义 discount_policy 成员。*/

Code9：作用域与成员函数

struct Base {
     int memfcn();
 };
 struct Derived : Base {
     int memfcn(int); // hides memfcn in the base
 };
Derived d; Base b;
b.memfcn();// ok: calls Base::memfcn
d.memfcn(10);// calls Base::memfcn
d.memfcn();// calls Derived::memfcn
d.Base::memfcn();  // error: memfcn with no arguments is hidden

/*可能比较奇怪的是第三个调用:
d.memfcn(); // error: Derived has no memfcn that takes no arguments
要确定这个调用,编译器需要查找名字 memfcn,并在 Derived 类中找到。 一旦找到了名字,编译器就不再继续查找了。这个调用与 Derived 中的 memfcn 定义不匹配,该定义希望接受 int 实参,而这个函数调用没有提供那样的实参, 因此出错。*/

From：

http://blog.csdn.net/liufei_learning/article/details/22364861