C++面向对象程序设计的一些知识点（2）

1、C++中三种继承方式及派生类中访问控制规则

（1）、C++支持的三种继承方式是public、protected、private。C++允许一个类同时以不同的方式对不同的基类加以继承。

（2）、

不同继承方式下基类成员在派生类中的访问控制

继承方式	基类成员访问控制
	public	protected	private
public	public	protected	no access
protected	protected	protected	no access
private	private	private	no access

注意：在派生类中，表中所述的访问控制“private”和“no access”存在很大的差别。对来自基类且在派生类中访问控制为“no access”的成员，

在派生类中是不可见的（自然，派生类的外部也不可见）；对来自基类且在派生类中访问控制为“private”的子成员，在派生类内部可以访问它

们，但在派生类外部不可以访问它们。

2、派生类对象内存模型分析

（1）、程序运行时派生类对象或存在于函数栈中或存在于系统给程序分配的堆中，它是一段物理内存。

（2）、派生类与基类之间的关系是一种“is-a”的关系，否则在逻辑上必然造成混乱。

（）

3、派生类对象的构造过程和析构过程

（1）、在继承方向上，先基类对象，后派生类子对象；在同一层次上，先包含类子对象，再本类子对象；如果在同一层次上存在多个包含类子

对象时，按照声明顺序来构造。

 #include <iostream>

 using namespace std;

 class EmbededA_Root
 {
 public:
     EmbededA_Root()
     {
         cout << "1_a:constructing embedded sub object A.\n";
     }
     ~EmbededA_Root()
     {
         cout << "1_a:destructing embedded sub object A.\n";
     }
 private:
 };
 class EmbededB_Root
 {
 public:
     EmbededB_Root()
     {
         cout << "1_b:constructing embedded sub object B.\n";
     }
     ~EmbededB_Root()
     {
         cout << "1_b:destructing embedded sub object B.\n";
     }
 private:
 };
 class RootBase
 {
 public:
     RootBase():embedA(), embedB()
     {
         cout << "1:constructing root base sub object.\n";
     }
     ~RootBase()
     {
         cout << "1:destructing root base sub object.\n";
     }
 private:

     EmbededB_Root embedB;
     EmbededA_Root embedA;
 };
 class Base:RootBase
 {
 public:
     Base()
     {
         cout << "2:constructing base sub object.\n";
     }
     ~Base()
     {
         cout << "2:destructing base sub object.\n";
     }
 private:
 };
 class Derived:public Base
 {
 public:
     Derived()
     {
         cout << "3:constructing derived sub object.\n";
     }
     ~Derived()
     {
         cout << "3:destructing derived sub object.\n";
     }
 private:
 };

 int main()
 {
     {
         Derived d;
     }
     int c;
     cin >> c;
     return ;
 }

运行结果是：

如果将类RootBase中的embedA和embedB声明顺序换一下的话，则结果是：

4、跨类的同名成员

（1）、派生类属性会隐藏其基类的同名属性，此时区分它们的方法是加上作用域限定符，即“积累名：：属性名”。

（2）、在非多态的情况下，派生类同名函数永远使基类同名函数隐藏起来（即使成员函数的特征表不同）。

5、基类对象与派生类对象之间的转换

（1）、用派生类对象给基类对象赋值或者用派生类初始化基类引用；此时是安全的，通常我们也应该重新编写赋值运算符的重载。

（2）、用基类对象给派生类对象赋值；此时是危险的，不应该这么做。

（3）、基类指针指向派生类对象地址；基类指针至少包含指针值和允许访问范围这样两个属性，而且此时基类指针允许访问的范围仅限于派生类对象子对象。

（4）、派生类指针指向基类对象；此时是危险的，不应该这么做。

（5）、C++提供的类型转换运算符。

6、多继承

（1）、非虚拟基类多继承；

 #include <iostream>

 using namespace std;

 class Base
 {
 public:
     Base(int a)
     {
         this->a = a;
         cout << "common base sub object being constructed.\n";
     }
     void show()
     {
         cout << a << endl;
     }
     ~Base()
     {
         cout << "deleting common base sub object.\n";
     }
 private:
     int a;
 };
 class B1:public Base
 {
 public:
     B1(int a, int b1):Base(a)
     {
         this->b1 = b1;
         cout << "base1 sub object being constructed.\n";
     }
     void showBase()
     {
         show();
     }
     ~B1()
     {
         cout << "deleting base1 sub object.\n";
     }
 private:
     int b1;
 };
 class B2:public Base
 {
 public:
     B2(int a, int b2):Base(a)
     {
         this->b2 = b2;
         cout << "base2 sub object being constructed.\n";
     }
     void showBase()
     {
         show();
     }
     ~B2()
     {
         cout << "deleting base2 sub object.\n";
     }
 private:
     int b2;
 };
 class D:public B2, public B1
 {
 public:
     D(int a1, int b1, int a2, int b2, int d):B1(a1, b1), B2(a2, b2)
     {
         this->d = d;
         cout << "derived sub object being constructed.\n";
     }
     void showB1Base()
     {
         B1::showBase();
     }
     void showB2Base()
     {
         B2::showBase();
     }
     ~D()
     {
         cout << "deleting derived sub object.\n";
     }
 private:
     int d;
 };

 int main()
 {
     {
         D d(, , , , );
         d.B1::show();
         d.B2::show();
         d.B1::showBase();
         d.B2::showBase();
         d.showB1Base();
         d.showB2Base();
     }
     int c;
     cin >> c;
     return ;
 }

此时基类对象在派生类对象中占有一个独立的内存空间。

（2）、虚拟基类多继承；

 #include <iostream>

 using namespace std;

 class Base
 {
 public:
     Base(int a)
     {
         this->a = a;
         cout << "common base sub object being constructed.\n";
     }
     void show()
     {
         cout << a << endl;
     }
     ~Base()
     {
         cout << "deleting common base sub object.\n";
     }
 private:
     int a;
 };
 class B1:virtual public Base
 {
 public:
     B1(int a, int b1):Base(a)
     {
         this->b1 = b1;
         cout << "base1 sub object being constructed.\n";
     }
     void showBase()
     {
         show();
     }
     ~B1()
     {
         cout << "deleting base1 sub object.\n";
     }
 private:
     int b1;
 };
 class B2:virtual public Base
 {
 public:
     B2(int a, int b2):Base(a)
     {
         this->b2 = b2;
         cout << "base2 sub object being constructed.\n";
     }
     void showBase()
     {
         show();
     }
     ~B2()
     {
         cout << "deleting base2 sub object.\n";
     }
 private:
     int b2;
 };
 class D:public B1, public B2
 {
 public:
     D(int a, int b1, int b2, int d):B1(a, b1), B2(a, b2), Base(a)
     {
         this->d = d;
         cout << "derived sub object being cosntructed.\n";
     }
     void showB1Base()
     {
         B1::showBase();
     }
     void showB2Base()
     {
         B2::showBase();
     }
     ~D()
     {
         cout << "deleting derived sub object.\n";
     }

 private:
     int d;
 };

 int main()
 {
     {
         D d(, , , );

         d.showB1Base();
         d.showB2Base();
     }
     int c;
     cin >> c;
     return ;
 }

此时基类子对象只包含一个。
7、继承综合应用实例

类关系UML图如图：

代码：

 #include <iostream>

 using namespace std;

 class Employee
 {
 public:
     Employee(char *name)
     {
         no = companyEmployee++;
         grade = ;
         pName = new char[strlen(name) + ];
         strcpy(pName, name);
         totalPay = 0.0;
     }
     ~Employee()
     {
         delete [] pName;
     }
 public:
     void pay(){}
     void promote(int increment)
     {
         grade += increment;
     }
     void displayInfo(){}
 protected:
     char *pName;
     int no;
     int grade;
     double totalPay;
     static int companyEmployee;
 private:
 };
 int Employee::companyEmployee = ; // 静态变量初始化

 class Technician:public Employee
 {
 public:
     Technician(char *name, int workHours = ):Employee(name)
     {
         rate = ; // 100元/小时
         this->workHours = workHours;
     }
     void setWorkhours(int workHours)
     {
         this->workHours = workHours;
     }
     void pay()
     {
         totalPay = workHours*rate;
     }
     void displayInfo()
     {
         promote();
         cout << "兼职技术人员：" << pName << "，编号：" << no
             << "，级别：" << grade << "，已付本月工资："
             << totalPay << endl;
     }
 private:
     double rate;
     int workHours;
 };
 class SaleMan:virtual public Employee
 {
 public:
     SaleMan(char *name, int sales = ):Employee(name)
     {
         ratio = 0.004;
         this->sales = sales;
     }
     void setSales(double sales)
     {
         this->sales = sales;
     }
     void pay()
     {
         totalPay = sales*ratio;
     }
     void displayInfo()
     {
         promote();
         cout << "推销员：" << pName << "，编号：" << no
             << "，级别：" << grade << "，已付本月工资："
             << totalPay << endl;
     }
 protected:
     double sales;
     double ratio;
 };
 class Manager:virtual public Employee
 {
 public:
     Manager(char *name, int monthlyPay = ):Employee(name)
     {
         this->monthlyPay = monthlyPay;
     }
     void setMonthlyPay(double monthlyPay)
     {
         this->monthlyPay = monthlyPay;
     }
     void pay()
     {
         totalPay = monthlyPay;
     }
     void displayInfo()
     {
         promote();
         cout << "经理：" << pName << "，编号：" << no
             << "，级别：" << grade << "，已付本月工资："
             << totalPay << endl;
     }
 protected:
     double monthlyPay;
 };
 class SaleManager:public SaleMan, public Manager
 {
 public:
     SaleManager(char *name):SaleMan(name), Manager(name), Employee(name)
     {
         monthlyPay = ;
         ratio = 0.002;
     }
     void pay()
     {
         totalPay = monthlyPay + sales*ratio;
     }
     void displayInfo()
     {
         promote();
         cout << "销售经理：" << pName << "，编号：" << no
             << "，级别：" << grade << "，已付本月工资："
             << totalPay << endl;
     }
 private:
 };

 int main()
 {
     Technician t("zhang san");
     t.setWorkhours();
     t.pay();
     t.displayInfo();

     SaleManager sm("li si");
     sm.setMonthlyPay();
     sm.setSales();
     sm.pay();
     sm.displayInfo();
     int c;
     cin >> c;
     return ;
 }