继承

最新推荐文章于 2024-10-23 14:49:19 发布

原创最新推荐文章于 2024-10-23 14:49:19 发布 · 236 阅读

1 ·

CC 4.0 BY-SA版权

一、类之间的关系

继承：在已有类的基础上创建新类的过程

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

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

二、基类和派生类

类继承关系的语法形式

class 派生类名: 基类名表

{

数据成员和成员函数声明

};

基类名表构成

访问控制基类名1，访问控制基类名2，… ，访问控制基类名n

访问控制表示派生类对基类的继承方式，使用关键字：

public 公有继承

private 私有继承

protected 保护继承

访问控制：不论种方式继承基类，派生类都不能直接使用基类的私有成员

派生类的生成过程

派生类的生成过程经历了三个步骤：

●吸收基类成员（全部吸收(构造、析构除外),但不一定可见）

●改造基类成员

●添加派生类新成员

(1) 吸收基类成员：在C++的继承机制中，派生类吸收基类中除构造函数和析构函数之外的全部成员。

(2) 改造基类成员：通过在派生类中定义同名成员（包括成员函数和数据成员）来屏蔽（隐藏）在派生类中不起作用的部分基类成员。

(3) 添加新成员：仅仅继承基类的成员是不够的，需要在派生类中添加新成员，以保证派生类自身特殊属性和行为的实现。

对于下面的继承关系：

classFather

{

int a,b;

public:

//成员函数

};

classSon:publicFather

{

int c;

public:

// 成员函数

};

#include <iostream>
using namespace std;
class A{
public:
	int a;
	int b;
private:
	int c;
protected:
	int d;
};
class B: public A
{ int c; };
main( ){
	cout << ” size of A is” << sizeof(A);
	cout << ” size of B is” << sizeof(B); }

#include<iostream>
using namespace std ;
class A
{ public :
      void  get_XY()   { cout << "Enter two numbers of x, y : " ;  cin >> x >> y ; }
      void  put_XY()    { cout << "x = "<< x << ", y = " << y << '\n' ; }
   protected:    int x, y ;
};
class B : public A
{ public :
      int  get_S() { return s ; };
      void  make_S()  { s = x * y ; };    	// 使用基类数据成员x，y
   protected:   int s;
};
class C : public B
{ public : 
      void  get_H()   { cout << "Enter a number of h : " ;  cin >> h ; } 
      int  get_V() { return v ; }
      void  make_V()  { make_S(); v = get_S() * h ; } 	// 使用基类成员函数
   protected:    int h, v;
};

1.公有继承

#include<iostream>
using namespace std ;
class A
{ public :
      void  get_XY()   { cout << "Enter two numbers of x, y : " ;  cin >> x >> y ; }
      void  put_XY()    { cout << "x = "<< x << ", y = " << y << '\n' ; }
   protected:    int x, y ;
};
class B : public A
{ public :
      int  get_S() { return s ; };
      void  make_S()  { s = x * y ; };    	// 使用基类数据成员x，y
   protected:   int s;
};
class C : public B
{ public : 
      void  get_H()   { cout << "Enter a number of h : " ;  cin >> h ; } 
      int  get_V() { return v ; }
      void  make_V()  { make_S(); v = get_S() * h ; } 	// 使用基类成员函数
   protected:    int h, v;
};


定义一个基类person（不定义构造函数）
姓名、性别、年龄(访问权限设置为私有)
定义公有的成员函数set_p()
定义公有的成员函数display_p(),显示person的信息
再由基类派生出学生类（不定义构造函数，采用公有继承的方式）
   增加学号、班级、专业和入学成绩
   定义公有成员函数set_t()
   定义成员函定义公有的成员函数display_s(),显示所有的信息
#include<iostream>
#include <string>
using namespace std;
class Person
{

	string name;
	int age;
	string sex;
public:
	void set_p()	{
		cout<<"name\tage\tsex"<<endl;
		cin>>name>>age>>sex;
	}
	void show_p()	{
 		cout<<name<<"  "<<age<<"  "<<sex<<endl;
	}
};
class student :public Person
{
	string no;
	string zhuanye;
	string t_class;
	float score;
public:
	void set_t(){
  	    set_p(); //调用继承于基类的成员函数访问继承于基类的私有数据成员
	    cout<<"zhuanye\tt_class\tscore"<<endl;
	    cin>>zhuanye>>t_class>>score;
	}
	void show_t()	{
		show_p();
		cout<<zhuanye<<"  "<<t_class<<"  "<<score<<endl;
	}
};

该问题的第二种解决方法Student_person3

#include<iostream>
#include <string>
using namespace std;
class Person
{

	string name;
	int age;
	string sex;
public:
	void set()	{
		cout<<"name\tage\tsex"<<endl;
		cin>>name>>age>>sex;
	}
	void show()	{
 		cout<<name<<"  "<<age<<"  "<<sex<<endl;
	}
};
class student :public Person
{
	string no;
	string zhuanye;
	string t_class;
	float score;
public:
	void set(){    //隐藏了基类中的同名成员       
	     Person::set(); //调用继承于基类的成员函数访问继承于基类的数据成员
   	     cout<<"zhuanye\tt_class\tscore"<<endl;
	     cin>>zhuanye>>t_class>>score;
	}
	void show()	{
		Person::show();
		cout<<zhuanye<<"  "<<t_class<<"  "<<score<<endl;
	}
};

重名成员

派生类定义了与基类同名的成员，在派生类中访问同名成员时屏蔽（hide）了基类的同名成员

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

类名:: 成员

1.重名数据成员

例：
class  base
  { public :
           int  a ,  b ;  
  } ;
class  derived : public  base
  { public :  
         int  b ,  c ; 
  } ;
void  f ()
{ derived  d ;
   d . a = 1 ;
   d . base :: b = 2 ;
   d . b = 3 ;
   d . c = 4 ;
};

#include<iostream>	
using namespace std ;
class A
{ public:	  
       int a1, a2 ;
      A( int i1=0, int i2=0 ) { a1 = i1; a2 = i2; }
      void print() 
         { cout << "a1=" << a1 << '\t' << "a2=" << a2 << endl ; }
};
class B : public A
{ public:	
       int b1, b2 ;
       B( int j1=1, int j2=1 ) { b1 = j1; b2 = j2; }
       void print()		//定义同名函数
         { cout << "b1=" << b1 << '\t' << "b2=" << b2 << endl ;

 void printAB()
        { A::print() ;		//派生类对象调用基类版本同名成员函数
           print() ;		//派生类对象调用自身的成员函数
       }
};
int main()
{ B  b ;        b.A::print();	b.printAB();  }

派生类中访问静态成员

Ø基类定义的静态成员，将被所有派生类共享（基类和派生类共享基类中的静态成员）

Ø 根据静态成员自身的访问特性和派生类的继承方式，在类层次体系中具有不同的访问性质

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

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

#include<iostream>
using namespace std ;
class B
{ public:
    static void Add() { i++ ; }
    static int i;
    void out() { cout<<"static i="<<i<<endl; }
};
int B::i=0;
class D : private B
{ public:    
      void f() 
       { i=5;
         Add();
         B::i++;
         B::Add();
       }
};
int main()
{ B x;  D y;
  x.Add();
  x.out();
  y.f();
  cout<<"static i="<<B::i<<endl;
  cout<<"static i="<<x.i<<endl;
  //cout<<"static i="<<y.i<<endl;
}

基类的初始化

Ø在创建派生类对象时用指定参数调用基类的构造函数来初始化派生类继承基类的数据

Ø 派生类构造函数声明为

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

Ø 构造函数执行顺序：基类——>对象成员——>派生类

// 例8-6  调用构造函数顺序测试，构造函数无参数
#include<iostream>
using namespace std ;
class  Base
  { public :  Base ( ) { cout << "Base created.\n" ;  }
  } ;
class  D_class : public  Base
  { public :  D_class ( ) { cout << "D_class created.\n" ;  }
  } ;
int main ( )
{ D_class d1 ; }

#include<iostream>
using namespace std ;
class  parent_class
{     int  data1 , data2 ;
   public :
       parent_class ( int  p1 , int  p2 ) { data1 = p1; data2 = p2; }
       int  inc1 () { return  ++ data1; }
       int  inc2 () { return  ++ data2 ; }
       void  display  ()  {cout << "data1=" << data1 << " , data2=" << data2 << endl ; }
};
class  derived_class : private  parent_class
{     int  data3 ;
       parent_class  data4 ;
   public:
       derived_class ( int  p1 , int  p2 , int  p3 , int  p4 , int  p5 ): parent_class ( p1 , p2 ) , data4 ( p3 , p4 )
           { data3 = p5 ; }

int  inc1 ( ) { return  parent_class :: inc1 ( ) ; }
       int  inc3 ( ) { return  ++ data3 ; }
       void  display ( )
          { parent_class :: display ( ) ;   data4.display ( ) ;
             cout << "data3=" << data3 << endl ;
          }
} ;
int main ( )
{ derived_class  d1 ( 17 , 18 , 1 , 2 , -5 ) ;   d1 . inc1 ( ) ;     d1 . display ( ) ;  }

派生类构造函数和析构函数的定义规则

派生类构造函数和析构函数的使用原则

1.基类的构造函数和析构函数不能被继承

2.如果基类没有定义构造函数或有无参的构造函数，派生类也可以不用定义构造函数

3.如果基类无无参的构造函数，派生类必须定义构造函数

4.如果派生类的基类也是派生类，则每个派生类只负责直接基类的构造

5.派生类是否定义析构函数与所属的基类无关

派生类的构造函数的定义

派生类的数据成员既包括基类的数据成员，也包括派生类新增数据成员。

问题1：如何对基类中的成员进行初始化？

最佳解决方案：调用基类构造函数对基类成员进行初始化。

派生类构造函数的定义

在C++中,派生类构造函数的一般格式为:

派生类::派生类名(参数总表):基类名(参数表)

{

// 派生类新增成员的初始化语句

}

注意：这是基类有构造函数且含有参数时使用

派生类析构函数

（1）当派生类中不含对象成员时

在创建派生类对象时,构造函数的执行顺序是：基类的构造函数→派生类的构造函数；

在撤消派生类对象时,析构函数的执行顺序是：派生类的析构函数→基类的析构函数。

（2）当派生类中含有对象成员时

在定义派生类对象时，构造函数的执行顺序：基类的构造函数→对象成员的构造函数→派生类的构造函数；

在撤消派生类对象时，析构函数的执行顺序：派生类的析构函数→对象成员的析构函数→基类的析构函数。

class B
{
public:
    B() { cout<<"B()"<<endl; }
    ~B() { cout<<"~B()"<<endl; }
};
class D : public B
{
public:
    D(){ cout<<"D()"<<endl; }
    ~D() { cout<<"~D()"<<endl; }
};
int main()
{
    D d;
    return 0;
}

多继承

》一个类有多个直接基类的继承关系称为多继承

》多继承声明语法

class 派生类名: 访问控制基类名1, 访问控制基类名2, … , 访问控制基类名n

{

数据成员和成员函数声明

}；

》类C可以根据访问控制同时继承类A和类B的成员，并添加自己的成员

多继承的派生类构造和访问

Ø多个基类的派生类构造函数可以用初始式调用基类构造函数初始化数据成员。

Ø执行顺序与单继承构造函数情况类似。多个直接基类构造函数执行顺序取决于定义派生类时指定的各个继承基类的顺序。

Ø一个派生类对象拥有多个直接或间接基类的成员。不同名成员访问不会出现二义性。如果不同的基类有同名成员，派生类对象访问时应该加以识别。