c++之继承一

has-A，uses-A 和 is-A

　　has-A ： 　　 包含关系，用以描述一个类由多个“部件类”构成。实现has-A关系用类成员表示，即一个类中的数据成员是另一种已经定义的类。

　　uses-A ：　　 一个类部分地使用另一个类。通过类之间成员函数的相互联系，定义友元或对象参数传递实现。

　　is-A   ：　   　机制称为“继承”。关系具有传递性,不具有对称性。 

　　 继承 是类之间定义的一种重要关系

 　　一个 B 类继承A类，或称从类 A 派生类 B

　　 类 A 称为基类（父类），类 B 称为派生类（子类）

　　c++支持多继承

类继承关系的语法形式

  class 派生类名 : 基类名表

   {

        数据成员和成员函数声明

   };

派生类对基类成员的使用，与继承访问控制和基类中成员性质有关

　　public：公有继承  基类的公有成员-》派生类的公有成员

       　　    基类的保护成员-》派生类的保护成员

　　private：私有继承  基类的公有成员和保护成员-》派生类的私有成员

　　protected：保护继承  基类的公有成员和保护成员-》派生类的保护成员

　　不论哪种方式继承基类，派生类都不能直接使用基类的私有成员

 

1.共有继承：：

　　

#include <iostream>
using namespace std;

class A
{
public:
    void get_XY()
    {
        cout << "Enter two numbers of x,y:"<< endl;
        cin>>x>>y;
    }
    void output_XY()
    {
        cout << "x=" << x << '	' << "y=" << y << endl;
    }
protected:    //保护数据成员，在类层次中可见
    int x,y;
};
class B: public A
{
public:
    int get_S()
    {
        return s;
    }
    void make_S()
    {
        s = x*y;
    }
protected:
    int s;
};
class C:public B
{
public:
    void getH()
    {
        cout <<"Enter a number h:";
        cin>>h;
    }
    int getV()
    {
        return v;
    }
    void makeV()
    {
        make_S();
        v = get_S() * h;
    }
protected:
    int h,v;
};
int main()
{ A objA ;
   B objB ;
   C objC ;
   cout << "It is object_A :
" ;
   objA.get_XY() ;
   objA.output_XY() ;
   cout << "It is object_B :
" ;
   objB.get_XY() ;
   objB.make_S() ;
   cout << "S = " << objB.get_S() << endl ;
   cout << "It is object_C :
" ;
   objC.get_XY() ;
   objC.getH();
   objC.makeV() ;
   cout << "V = " << objC.getV() << endl ;
}

2.私有继承：

　　

#include<iostream>
using namespace std ;
class A
{ public :
      void  get_XY()
      {
          cout << "Enter two numbers of x and y : " ;
          cin >> x >> y ; 
      }
      void  put_XY() 
      { 
          cout << "x = "<< x << ", y = " << y << '
' ; 
      }
  protected:
      int x, y ;
};
class B : private A
{ public :
      int  get_S() 
      { 
          return s ;
      }
      void  make_S()
      { 
        get_XY();   
        s = x * y ;  
      }    
   private:        
       int s ;
};
int main()
{ B objB ;    
   cout << "It is object_B :
" ;
   objB.make_S() ;
   cout << "S = " << objB.get_S() << endl ;
 }

3。重名成员

　　

派生类定义了与基类同名的成员，在派生类中访问同名成员

    时屏蔽了基类的同名成员

在派生类中使用基类的同名成员，显式地使用类名限定符：

类名 :: 成员

基类成员的作用域延伸到所有派生类

 4，在派生类中访问静态成员

 基类定义的静态成员，将被所有派生类共享

根据静态成员自身的访问特性和派生类的继承方式，在类层次

    体系中具有不同的访问性质

派生类中访问静态成员，用以下形式显式说明：

  类名 :: 成员

 或通过对象访问  对象名 . 成员

#include <iostream>
using namespace std;

class A
{
public:
    //静态成员变量
    static int i;
    //静态成员函数
    static void add()
    {
        i++;
    }
    void output()
    {
        cout << "static i = " << i << endl;
    };
};
//必须进行初始化，否则会报错
int A::i = 0;
class B: private A
{
public:
    void f()
    {
        i = 5;
        add();
        B::i++;
        B::add();
    }
};
void main()
{
    //不管是怎么调用i，操作的都是同一个数据
    B b;
    A a;
    a.add();
    a.output();
    b.f();
    //访问A类的静态数据成员
    cout << "static i=" << A::i << endl;
    //通过A类的对象访问静态数据成员
    cout << "static i=" << a.i << endl;
    //下面的代码会报错，因为i是类B的私有静态数据成员，不能直接访问
    //cout << "static i=" << b.i << endl;
}

#include <iostream>
using namespace std;

class A
{
public:
    //静态成员变量
    static int i;
    //静态成员函数
    static void add()
    {
        i++;
    }
    void output()
    {
        cout << "static i = " << i << endl;
    };
};
//必须进行初始化，否则会报错
int A::i = 0;
class B: private A
{
public:
    void f()
    {
        i = 5;
        add();
        B::i++;
        B::add();
    }
};
void main()
{
    //不管是怎么调用i，操作的都是同一个数据
    B b;
    A a;
    a.add();
    a.output();
    b.f();
    //访问A类的静态数据成员
    cout << "static i=" << A::i << endl;
    //通过A类的对象访问静态数据成员
    cout << "static i=" << a.i << endl;
    //下面的代码会报错，因为i是类B的私有静态数据成员，不能直接访问
    //cout << "static i=" << b.i << endl;
}

5，基类的初始化

  建立一个类层次后，通常创建某个派生类的对象，包括使用基类的数据和函数。

  C++提供一种机制，在创建派生类对象时用指定参数调用基类的构造函数来初始化派生类继承基类的数据

  派生类构造函数声明为

派生类构造函数 ( 变元表 ) : 基类 ( 变元表 ) , 对象成员1( 变元表 )

   … 对象成员n ( 变元表 ) ；

构造函数执行顺序：基类 à 对象成员à 派生类。

#include <iostream>
using namespace std;

class ParentClass
{
private:
    int date1,date2;
public:
    ParentClass(int d1,int d2)
    {
        date1 = d1;
        date2 = d2;
    }
    int increase1()
    {
        return ++date1;
    }
    int increase2()
    {
        return ++date2;
    }
    void display()
    {
        cout << "date1 = " << date1 << ";" << "date2 = " << date2 << endl;
    }
};
class DerivedClass:private ParentClass
{
private:
    int date3;
    ParentClass date4;
public:
    //使用初始化式，调用基类构造函数初始化成员变量和构造对象成员
    DerivedClass(int d1,int d2,int d3,int d4,int d5):ParentClass(d1,d2),date4(d4,d5)
    {
        date3 = d3;
    }
    int increase1()
    {
        return ParentClass::increase1();
    }
    int increase3()
    {
        return ++date3;
    }
    void display()
    {
        ParentClass::display();
        cout << "date3 = " << date3 << endl;
        date4.display();
    }
};
void main()
{
    DerivedClass d1(17,18,1,2,-5);
    d1.increase1();
    d1.display();
}