原创 C/C++复习之路——王道程序员求职宝典——第九章《面向对象编程》

布满荆棘的人生 2023-03-03 06:30 4阅读 0赞

### 文章目录 ###

*   *   *  继承时导致的二义性

class <派生类>:<继承方式1> <基类名1>,<继承方式2> <基类名2>, ...{ 
    	<派生类新定义成员>
    };

*  继承方式：public、private、protected

基类成员在派生类中的访问属性

<table> 
 <thead> 
  <tr> 
   <th align="center">基类成员</th> 
   <th align="center">private</th> 
   <th align="center">protect</th> 
   <th align="center">public</th> 
   <th align="center">private</th> 
   <th align="center">protect</th> 
   <th align="center">public</th> 
   <th align="center">private</th> 
   <th align="center">protect</th> 
   <th align="center">public</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">派生方式</td> 
   <td align="center">private</td> 
   <td align="center">private</td> 
   <td align="center">private</td> 
   <td align="center">protect</td> 
   <td align="center">protect</td> 
   <td align="center">protect</td> 
   <td align="center">public</td> 
   <td align="center">public</td> 
   <td align="center">public</td> 
  </tr> 
  <tr> 
   <td align="center">派生类中</td> 
   <td align="center">不可见</td> 
   <td align="center">private</td> 
   <td align="center">private</td> 
   <td align="center">不可见</td> 
   <td align="center">protected</td> 
   <td align="center">protected</td> 
   <td align="center">不可见</td> 
   <td align="center">protected</td> 
   <td align="center">public</td> 
  </tr> 
  <tr> 
   <td align="center">外部</td> 
   <td align="center">不可见</td> 
   <td align="center">不可见</td> 
   <td align="center">不可见</td> 
   <td align="center">不可见</td> 
   <td align="center">不可见</td> 
   <td align="center">不可见</td> 
   <td align="center">不可见</td> 
   <td align="center">不可见</td> 
   <td align="center">可见</td> 
  </tr> 
 </tbody> 
</table>

例。类child从类parent保护派生，则child可以访问类parent中的（）成员？  
A.public成员  B.private成员  C.protected成员  D.都不能访问  
解析：AC。内部访问

例。类child从类parent保护派生，若有child c;那么c可以访问类parent中的（）成员？  
A.public成员  B.private成员  C.protected成员  D.都不能访问  
解析：D。外部访问

### 继承时导致的二义性 ###

1）在公有继承方式（私有、保护继承时，不能隐式转换）下，派生类的对象/对象指针/对象引用可以赋值给基类的对象/对象指针/对象引用（发生隐式转换），基类的对象/对象指针/对象引用不能赋值给派生类的对象/对象指针/对象引用。因为派生类包含了基类的所有信息，而基类缺乏派生类中的信息。如：

class A{ };
    class B: public A{ }；
    A a;
    B b;

则

a=b;	//合法，派生类向基类隐式转换
    b=a;	//错误，基类向派生类转换，语句1
    A* pa=&b;	//合法，隐式转换
    B* pb=&a;	//错误，语句2
    A& ra=b;	//合法，隐式转换
    B& rb=a;	//错误，语句3

2）C++允许把基类对象指针/引用强制转换（显示）成派生类的对象指针/引用，如1）中代码，语句2可以改为：

B* pb=(B*)&a;	//合法

语句3可以改为：

B& pb=(B&)a;	//合法

例。下述代码的输出结果是什么？

class base1{ 
        char c[16];
    public:
        void printthis1(){ 
            cout<< "base1 this "<<this<<endl;
        }
    };
    class base2{ 
        char c[16];
    public:
        void printthis2(){ 
            cout<< "base2 this "<<this<<endl;
        }
    };
    class member1{ 
        char c[16];
    public:
        void printthism1(){ 
            cout<< "member1 this "<<this<<endl;
        }
    };
    class member2{ 
        char c[16];
    public:
        void printthism2(){ 
            cout<< "member2 this "<<this<<endl;
        }
    };
    class mi:public base1, public base2{ 
        member1 m1;
        member2 m2;
    public:
        void printthis(){ 
            cout<<"m1 this "<<this<<endl;
            printthis1();   //调用继承自base1的printthis1函数
            printthis2();   //调用继承自base2的printthis2函数
            m1.printthism1();
            m2.printthism2();
        }
    };
    int main(){ 
        mi MI;
        cout<<"sizeof(mi)="<<sizeof(mi)<<endl;
        MI.printthis();
        base1* b1=&MI;
        base2* b2=&MI;
        cout<<"base 1 pointer=" <<b1<<endl;
        cout<<"base 2 pointer=" <<b2<<endl;
    }

解析：输出为：  
sizeof(mi)=64  
m1 this 0x61fe00  
base1 this 0x61fe00  
base2 this 0x61fe10  
member1 this 0x61fe20  
member2 this 0x61fe30  
base 1 pointer=0x61fe00  
base 2 pointer=0x61fe10  
  每一个类都有打印一个this指针函数，这些类通过多重继承和组合被装配成类mi，它打印自己和其他所有字对象的地址，有主程序调用这些打印功能。可以清楚地看到，能在一个相同的对象中获得两个不同的this指针。  
  派生对象MI的起始地址和它的基类列表中的第一个类（base1）的地址是一直的，第二个类base2的地址随后，接着根据声明的次序安排成员对象(member1、member2的地址)。当向base1和base2选行上行转换时（语句“base1\* b1=&MI;”和语句“base2\* b2=&MI;”），产生的指针表面上是指向同一个对象，而实际上有不同的this指针，b1指向base1类的子对象，b2指向base2类的子对象。

一般来说，在派生类中对基类成员的访问应该具有唯一性，但是在多基类继承时，如果多个基类中存在同名成员的情况，造成编译器无从判断具体要访问哪个基类中的成员，则称为**基类成员访问的二义性问题。**  
  解决方法：可以使用成员名限定来消除二义性，如：

class A{ 
    public:
    	void print(){ cout<<"Hello, this is A."<<endl;}
    };
    class B{ 
    public:
    	void print(){ cout<<"Hello, this is B."<<endl;}
    };
    class C: public A, public B{ 
    public:
    	void display(){ print();}
    };

可以修改为：

void display(){ 
    	A::print();
    }

例。下述代码的输出结果是什么？

class base{ 
    public:
        virtual void disp(){ cout<<"hello base1"<<endl;}
        void disp2(){ cout<<"hello base2"<<endl;}
    };
    class child1:public base{ 
    public:
        void disp(){ cout<<"hello child1"<<endl;}
        void disp2(){ cout<<"hello child2"<<endl;}
    };
    int main(){ 
        base * base=NULL;
        child1 obj;
        base=&obj;
        base->disp();
        base->disp2();
    }

解析：  
hello child1  
hello base2

*  不加virtual时，具体调用哪个模板的函数只取决于指针本身的类型，和指针所指对象的类型无关。
 *  加virtual时，具体调用哪个模板的函数不再取决于指针本身的类型，而是取决于指针所指对象的类型。

例。以下代码的输出结果是（）。

class B{ 
    public:
        B(){ 
            cout<<"B constructor, ";
            s = "B";
        }
        void f(){ cout<<s;}    
    private:
        string s;
    };
    class D: public B{ 
    public:
        D():B(){ 
            cout<<"D constructor, ";
            s = "D";
        }
        void f(){ cout<<s;}    
    private:
        string s;
    };
    
    int main(){ 
        B *b=new D();
        b->f();
        ((D*)b)->f();
        delete b;
        return 0;
    }

解析：输出结果是：  
B constructor, D constructor, BD  
若在B类中的函数f前加上virtual关键字，，则输出结果为：  
B constructor, D constructor, DD

class A{ 
    public:
        virtual void fun(int number=10){ 
            cout<<"A::Fun with number "<<number<<endl;
        }
    };
    class B: public A{ 
    public:
        virtual void fun(int number=20){ 
            cout<<"B:Fun with number "<<number<<endl;
        }
    };
    
    例。下列代码的输出是什么？
    int main(){ 
        B b;
        A &a=b;
        a.fun();
        return 0;
    }

解析：B:Fun with number 10  
虚函数动态绑定到B，但缺省实参数是编译时候确定的10，而非20。