C++复习3.继承的相关概念_#include <iostream h> class base ( private. int y -优快云博客

本文通过多个示例详细解析了C++中继承的概念，包括单继承、多继承、虚继承等，并介绍了继承过程中访问控制符的作用及虚析构函数的重要性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

C++继承经典例子

#include <iostream.h>
class Base {
private:
        int b;
public:
        Base( ){}
        Base(int i) : b(i) { }
        int get_number( ) {
          return b;
        }
        void print( ) {
          cout << b << endl;
        }        
};

class Derived : public Base {
  private:
        int d;
  public:
// 构造函数，必须初始化父类对象的部分
        Derived( int i, int j ) : Base(i), d(j) { };        
// 子类中的print()将会覆盖父类中的print()
        void print( ) {
                cout << get_number( ) << " ";        
// access number through get_number( )
                cout << d << endl;
        }
};

int main( ) {
        Base a(2);
        Derived b(3, 4);
        cout << "a is ";
        a.print( );                // print( ) in Base
        cout << "b is ";
        b.print( );                // print( ) in Derived
        cout << "base part of b is "; 
        b.Base::print( );                // print( ) in Base
        return 0;
}

没有虚析构函数，继承类没有析构

//Example: non- virtual destructors for dynamically allocated objects.

#include <iostream.h>
#include <string.h>
class Thing { 
 public:
  virtual void what_Am_I( ) {
    cout << "I am a Thing./n";
  }
  ~Thing() {
    cout<<"Thing destructor"<<endl;
  }
};

class Animal : public Thing {  
 public:
  virtual void what_Am_I( ) {
    cout << "I am an Animal./n";
  }
  ~Animal() {
    cout << "Animal destructor" << endl;
  }
};
int main( ) {
   Thing *t =new Thing;      
   Animal*x = new Animal;
   Thing* array[2];
   array[0] = t;                                // base pointer
   array[1] = x;               
    for (int i=0; i<2; i++)  array->what_Am_I( ) ;
   delete array[0];
   delete array[1];
   return 0;
}

纯虚函数，多态

#include <iostream.h>
#include <math.h>
class Point {
private:
        double x;
        double y;
public:
        Point(double i, double j) : x(i), y(j) { } 
        void print( ) const { 
          cout << "(" << x << ", " << y << ")";
        }
};

class Figure {
private:
        Point center;
public:
        Figure (double i = 0, double j = 0) : center(i, j) { }         

        Point& location( ) {
          return center;
        }                  // return an lvalue
        void move(Point p) {
          center = p;
          draw( );
        }
        virtual void draw( ) = 0; // draw the figure
        virtual void rotate(double) = 0; 
        // rotate the figure by an angle                
};

class Circle : public Figure {
private:
        double radius;
public:
        Circle(double i = 0, double j = 0, double r = 0) : Figure(i, j), radius(r) { }
        void draw( ) {
                cout << "A circle with center ";
                location( ).print( );
                cout << " and radius " << radius << endl;
        }
        void rotate(double) {
                cout << "no effect./n";
        }        // must be defined
};

class Square : public Figure {
private:
        double side;   // length of the side
        double angle;  // the angle between a side and the x-axis
public:
        Square(double i = 0, double j = 0, double d = 0, double a = 0) : Figure(i, j), side(d), angle(a) { }
        void draw( ) {
                cout << "A square with center ";
                location( ).print( );
                cout << " side length " << side << "./n"  
                << "The angle between one side and the X-axis is " << angle << endl;
        }
        void rotate(double a) {
               angle += a;
                cout << "The angle between one side and the X-axis is " << angle << endl;
        }
        void vertices( ) {
                cout << "The vertices of the square are:/n";
     // calculate coordinates of the vertices of the square
          }
};

int main( ) {
        Circle c(1, 2, 3);
        Square s(4, 5, 6);
        Figure *f = &c, &g = s;
        f -> draw( );
        f -> move(Point(2, 2));
        g.draw( );
        g.rotate(1);

        s.vertices( );
// Cannot use g here since vertices( ) is not a member of Figure.
        return 0;
}

#include <iostream.h>
#include <string.h>
class Thing { 
public:
  virtual void what_Am_I( ) {
    cout << "I am a Thing./n";
  }
  ~Thing() {
    cout<<"Thing destructor"<<endl;
  }
};

class Animal : public Thing { 
public:
  virtual void what_Am_I( ) {
    cout << "I am an Animal./n";
  }
  ~Animal() {
    cout<<"Animal destructor"<<endl;
  }
};

int main( ) {
   Thing t ; 
   Animal x ;
   Thing* array[2];
   array[0] = &t;                        // base pointer
   array[1] = &x;        
          for (int i=0; i<2; i++)  array->what_Am_I( ) ;
   return 0;
}

多继承

#include <iostream.h>
class A {
  private:
        int a;
  public:
        A(int i) : a(i) { }
        virtual void print( ) {
          cout << a << endl;
        }
        int get_a( ) {
          return a;
        }
};

class B {
private:
        int b;
public:
        B(int j) : b(j) { }
        void print( ) {
          cout << b << endl;
        }
        int get_b( ) {
          return b;
        }
};

class C : public A, public B {
        int c;
public:
        C(int i, int j, int k) : A(i), B(j), c(k) { }
        void print( )  {
          A::print( ); 
          B::print( );
         }
        // use print( ) with scope resolution
        void get_ab( ) {
          cout << get_a( ) << " " << get_b( ) << endl;
        }
        // use get_a( ) and get_b( ) without scope resolution
};

int main( )
{
        C x(5, 8, 10);
        A* ap = &x;
        B* bp = &x;
        ap -> print( );                // use C::print( );
        bp -> print( );                // use B::print( );
//        bp -> A::print( );                // as if x is inherited from B only,
                                                // cannot access A::print( );
        x.A::print( );                // use A::print( );
        x.get_ab( );
        return 0;
}

共同基类的多继承

#include <iostream.h>
class R {
  int r;
  public:
        R(int anInt) { 
          r = anInt;
        }
        printOn() { 
          cout<<"r="<<r<<endl;
        } ; 
 };

class A : public R {
int a;
public:
        A(int int1,int int2):R(int2) { 
          a = int1;
        }
};

class B : public R {
  int b;
  public:
        B(int int1,int int2):R(int2) { 
          b = int1;
        }
};

class C : public A, public B {
  int c;
  public:
  C(int int1,int int2, int int3):A(int2,int3), B(int2,int3 { 
    c = int1;
  }
};

int main( ) {    
  int i;
  R rr(10);      
  A aa(20,30);      
  B bb (40,50);
  C cc(5, 7, 9);
  rr.printOn();    
  aa.printOn();      //inherits R printOn  
  bb.printOn();      //inherits R printOn
        //cc.printOn();                  //would give error
        return 0;}

虚基类

#include <iostream.h>
class R { 
  int r;
public:
  R (int x = 0) : r(x) { }   // constructor in R
  void f( ) { 
    cout<<"r="<<r<<endl;
  }     
  void printOn() {
    cout<<"printOn R="<<r<<endl;
  }
};

class A : public virtual R {  
  int a;
public:
   A (int x, int y) : R(x), a(y)  { } // constructor in A
   void f( ) { 
     cout<<"a="<<a<<endl;
     R::f();
   }
};

class B : public virtual R {
   int b;
public:
   B(int x, int z) : R(x), b(z) { }// constructor in B
   void f( ) { 
     cout<<"b="<<b<<endl;
   }
};

class C : public A, public B { 
  int c;
public:
// constructor in C, which constructs an R object first
  C(int x, int y, int z, int w) : R(x), A(x, y), B(x, z), c(w) { }

  void f( ){ 
  cout<<"c="<<c<<endl;
  A::f(); 
  B::f();
  }
};

int main() {  
   R rr(1000);
   A aa(2222,444);
   B bb(3333,111);
   C cc(1212,345,123,45);
   cc.printOn();     //uses R printOn but only 1 R..no ambiguity
   cc.f();                // shows multiple call of the R::f()
}

#include <iostream.h>
class R { 
  int r;
public:
   R (int x = 0) : r(x) { }   // constructor in R
   void f( ) {
     cout<<"r="<<r<<endl;
   }
};

class A : virtual public R { 
  int a ;
protected:
   void fA( ) {
     cout<<"a="<<a<<endl;
   }
public:
        A (int x, int y) : R(x), a(y)  { } // constructor in A
        void f( ) {
          fA( ); 
          R::f( );
        }
};

class B : virtual public R {  
  int b;
protected:
  void fB( ) {
    cout<<"b="<<b<<endl;
  }
public:
        B (int x, int y) : R(x), b(y)  { } // constructor in A
        void f( ) {
          fB( ); 
          R::f( );
        }
};

class C : public A, public B { 
   int c;
protected:
   void fC( ) { 
     cout<<"c="<<c<<endl;
   }        
public:
C(int x, int y, int z, int w) : R(x), A(x, y), B(x, z), c(w) { }
   void f( ) {  
      R::f( );                    // acts on R stuff only
      A::fA( );            //acts on A stuff only
      B::fB( );                   // acts on B stuff only
      fC( );                  // acts on C stuff only
     }
};

int main() {  
   R rr(1000);
   A aa(2222,444);
   B bb(3333,111);
   C cc(1212,345,123,45);
   cc.f();
}


##**私有继承**

// Access levels

#include <iostream.h>
class Base {
private:
        int priv;
protected:
        int prot;
        int get_priv( ) {return priv;}
public:
        int publ;
        Base( );
        Base(int a, int b, int c) : priv(a), prot(b), publ(c) { }
        int get_prot( ) {return prot;}
        int get_publ( ) {return publ;}
};

class Derived1 : private Base  {       // private inheritance
  public:
        Derived1 (int a, int b, int c) : Base(a, b, c) { }
        int get1_priv( ) {return get_priv( );}
        // priv not accessible directly
        int get1_prot( ) {return prot;}
        int get1_publ( ) {return publ;}
};

class Leaf1 : public Derived1 {
public:
        Leaf1(int a, int b, int c) : Derived1(a, b, c) { }
        void print( ) {
        cout << "Leaf1 members: " << get1_priv( ) << " "
//                        << get_priv( )        // not accessible
                        << get1_prot( ) << " "
//                        << get_prot( )         // not accessible
//                        << publ         // not accessible
                        << get1_publ( ) << endl;
        }  // data members not accessible.  get_ functions in Base not accessible
};

class Derived2 : protected Base {// protected inheritance
  public:
    Derived2 (int a, int b, int c) : Base(a, b, c) { }
};

class Leaf2 : public Derived2 {
  public:
    Leaf2(int a, int b, int c) : Derived2(a, b, c) { }
    void print( ) {
        cout << "Leaf2 members: " << get_priv( ) << " "
//                        << priv                 // not accessible
<< prot << " " << publ << endl;
    }  // public and protected data members accessible.  get_ functions in Base accessible. 
};

class Derived3 : public Base { // public inheritance
  public:
    Derived3 (int a, int b, int c) : Base(a, b, c) { }
};

class Leaf3 : public Derived3 {
  public:
        Leaf3(int a, int b, int c) : Derived3(a, b, c) { }
        void print( ) {
            cout << "Leaf3 members: " << get_priv( ) << " "
                        << prot << " "
                        << publ << endl;
        }  // public and protected data members accessible.  get_ functions in Base accessible
};

int main( ) {
        Derived1 d1(1, 2, 3);
        Derived2 d2(4, 5, 6);
        Derived3 d3(7, 8, 9);
//        cout << d1.publ;                // not accessible
//        cout << d1.get_priv( );        // not accessible
//        cout << d2.publ;                // not accessible
//        cout << d2.get_priv( );        // not accessible
        cout << d3.publ;                // OK
        cout << d3.get_prot( );        // OK
        Leaf1 lf1(1, 2, 3);
        Leaf2 lf2(4, 5, 6);
        Leaf3 lf3(7, 8, 9);
//         cout << lf1.publ << endl;                    // not accessible
//         cout << lf2.publ << endl;                // not accessible
        cout << lf3.publ << endl;                 // OK
        return 0;
}

多级继承

// Point-Circle-Cylinder

#include <iostream.h>
// THE POINT CLASS
class Point {
friend ostream & operator<<(ostream &,Point &);
public:

//  constructor
        Point (double xval =0, double yval=0 ) { 
        x=xval; 
        y=yval;
        }  
protected:       // accessed by derived class
        double  x;
        double  y;
};
ostream & operator << (ostream & os,
                              Point &  apoint)
{
cout <<" Point:X:Y: "<<apoint.x << "," 
                      << apoint.y<< "/n";
  return os;  
}
//The Circle class  inherits from class Point
class Circle : public Point
{
friend ostream & operator<<(ostream &,Circle&);
public:
Circle (double r=0,double xval=0,double yval=0) 
                             :Point(xval,yval), radius(r)
{ 
//radius = r;
}
double area()
{ 
return (3.14159* radius *radius);
}
protected:
  double radius;
};

//note casting circle to point
ostream & operator <<(ostream & os, Circle & aCircle)
{
cout<< "Circle:radius:" << aCircle.radius;
os<< aCircle.x << "/n"; 
os<< aCircle.y << "/n";        
return os;      
}
// THE CYLINDER CLASS
class  Cylinder  : public Circle
{
friend ostream & operator << (ostream & ,Cylinder &);
public:
Cylinder (double hv=0,double rv=0, 
                      double xv=0,double yv=0 )
                           : Circle( xv,yv,rv)
{
height = hv;
}        
double  area ( );
protected:     // may have derived classes
        double  height;
};
double Cylinder :: area ( )
{ // Note that cylinder area uses Circle area
return  2.0* Circle::area() + 2.0*3.14159* radius*height;
}
ostream & operator << (ostream & os,
                        Cylinder & acylinder)
{ 
cout << "cylinder dimensions: ";
  cout << "x: " <<acylinder.x;
  cout << "  y: " <<acylinder.y ;
  cout << "  radius: " <<acylinder.radius ;
  cout << "  height: " <<acylinder.height 
                        << endl;
  return os; 
}
int main(void)
{
Point p(2,3);
Circle c(7,6,5);
Cylinder cyl(10,11,12,13);
cout << p;
cout << c;
cout << "area of cirle:" << c.area() << endl;
cout<< cyl;
cout<<"area of cylinder:"<< cyl.area()<<endl ;
cout<<"area of cylinder base is "  
                 << cyl.Circle::area() << endl;
return 0;
}

protected 访问控制属性在继承的意义

//Example of treating derived class object as base class objects. Point------Circle
#include <iostream.h>
// THE POINT CLASS
class Point
{ 
friend ostream & operator<<(ostream &,Circle&);
public:
Point (double xval =0, double yval=0 ) { x=xval; y=yval;};  
public:
void print()
{
cout <<" Point:X:Y: "<<x << "," <<y<< "/n";
}
protected:       // accessed by derived class
double  x;    double  y;
};
ostream & operator << (ostream & os, Point &  apoint)
{
cout <<" Point:X:Y: "<<apoint.x << ","<< apoint.y<< "/n";
  return os;  
}

//The Circle class  inherits from class Point
class Circle : public Point
{
friend ostream & operator<<(ostream &,Circle&);
public:
Circle (double r=0,double xval=0,double yval=0):Point(xval,yval)
{ radius = r;};
void print()
{
cout<< "Circle:radius:" <<radius<<endl;
cout <<" Point:X:Y: "<<x << "," <<y<< "/n";
}
double area()
{ return (3.14159* radius *radius);};
protected:
double radius;
};
//note casting circle to point
ostream & operator <<(ostream & os, Circle & aCircle)
{
cout<< "Circle:radius:" << aCircle.radius;
cout<< (Point) aCircle << "/n";           
return os;      
}

//We will look at a few main programs based on previous class definitions. Casting and assignments
void main (void )
{
Point p(2,3);         cout <<"Point P=  "<< p;
Point pp(0,0);       cout <<"Point PP=  "<< pp;
Circle c(7,6,5);     cout <<"Circle c=  "<< c;        //radius =7
pp = p;             cout <<"Point PP=  "<< pp;    //built in assign =
// a circle is a member of the point class so assign a circle to a point.
pp = c;           //legal; also assignment O.K.
cout <<"Point PP=  "<< pp;
pp= (Point) c;    // but better  use the cast
cout <<"Point PP=  "<< pp;  //note we get only the point part of the Circle
//c = (Circle) pp;   //  illegal Cannot convert 'class Point' to 'class Circle'
//c=pp;                 //illegal assignment not defined
Point*  p;
p = &c;
P->print();    //call base class print
((Circle*)p)->print();
Point& r = c;
r.print();
((Circle&)r).print();
}

类的兼容性规则

#include <iostream.h>
class Base
{ 
public:  
void func( ) 
{cout << "Base class function./n";} 
};
class Derived : public Base
{ 
public:  
void func( ) 
{cout << "Derived class function./n";}
};
void foo(Base b)
{ b.func( ); }
int main( )
{
   Derived d;
   Base b;
   Base * p = &d;
   Base& br = d;
   b = d;
   b.func( );
   d.func( );
   p -> func( );
   foo(d);
   br.func( );
   return 0;
}

虚析构函数，防止内存泄露

#include <iostream.h>
#include <string.h>
class Base
{
protected:
        int id;
        char * name;
public:
        // default constructor
        Base(int a = 0, char * s = "") : id(a)
        {
                if (!s) 
{ 
name = NULL; 
}
                else
                {
                        name = new char[strlen(s) + 1];
                        strcpy(name, s);
                }
                cout << "base default constructor/n";
        }
                // copy constructor
        Base(const Base& b) : id(b.id)
        {
                if (!b.name) { name = NULL; }
                else
                { 
                        name = new char[strlen(b.name) + 1];
        strcpy(name, b.name);
}
                    cout << "base copy constructor/n";
        } 
        // destructor
      ~Base( ) 
        {
            if( name != NULL )        delete [ ] name; 
                cout << "base destructor/n";
        }
        const Base& operator= (const Base& b);                
friend ostream& operator << (ostream&, const Base&);
};
const Base& Base:perator= (const Base& b)
{
        if (this != &b)                        // Check if an object is assigned to itself.
        {
             id = b.id;
                delete [ ] name;                //  Destroy the old object.
                if (!b.name) { name = NULL; }
                else
                {
        name = new char[strlen(b.name) + 1];
        strcpy(name, b.name);
                }
        }
            cout << "base assignment operator/n";
        return *this;
}
ostream& operator << (ostream& out, const Base& b)
{
        out << "Base member id = " << b.id << endl;
        out << "Base member name = " << b.name << endl;

        return out;
}
class Derived : public Base
{
private:
        float f;
        char * label;
public:
        // default constructor
        Derived(int a = 0, char * s = "", float x = 0, char * t = "") : Base(a, s), f(x)
        {
                if (!t) { label = NULL; }
                else
                {
        label = new char [strlen(t) + 1]; 
        strcpy(label, t);
}
                cout << "derived default constructor/n";
        }
        // copy constructor
        Derived(const Derived& d) : Base(d), f(d.f)
                // d used as an instance of Base
        {
                if(!d.label) { label = NULL; }
                else
                {
                        label = new char [strlen(d.label) + 1];
        strcpy(label, d.label);
}
                cout << "derived copy constructor/n";
        }
        // destructor
        ~Derived( )          
        {
                delete [ ] label; 
                cout << "derived destructor/n";
        }
        const Derived& operator= (const Derived& d);
friend ostream& operator << (ostream&, const Derived&);
};
const Derived& Derived:perator= (const Derived& d) {
        if (this != &d) {
                delete [ ] label;
                Base:perator=(d);        //  Assign the Base part of d to the Base
// part of the object that calls this operator;
f = d.f;
if (!d.label) { label = NULL; 
} else {
        label = new char [strlen(d.label) + 1];
                        strcpy(label, d.label);
       }
                cout << "derived assignment operator/n";
        }
        return *this;
}
ostream& operator << (ostream& out, const Derived& d) {
        out << (Base)d; // Convert d to Base object to output Base members.
        out << "Derived member f = " << d.f << endl;
        out << "Derived member label = " << d.label << endl;
        return out;
}
int main( ) {
        Derived d1;
        Derived  d2(d1);
        return 0;
}