c++继承与多态经典例子【转自网络大神】

超、凢脫俗 2022-08-05 00:49 206阅读 0赞

c++继承经典例子  
\#include <iostream.h>

class Base  
\{  
private:  
        int b\_number;  
public:  
        Base( )\{\}  
        Base(int i) : b\_number (i) \{ \}  
        int get\_number( ) \{return b\_number;\}  
        void print( ) \{cout << b\_number << endl;\}          
\};

class Derived : public Base  
\{  
private:  
        int d\_number;

public:  
// constructor, initializer used to initialize the base part of a Derived object.  
        Derived( int i, int j ) : Base(i), d\_number(j) \{ \};          
        // a new member function that overrides the print( ) function in Base  
        void print( )   
        \{  
                cout << get\_number( ) << " ";          
                // access number through get\_number( )  
                cout << d\_number << 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;\}  
\};

void 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 ;  
\}

--------------------

纯虚函数，多态

\#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;\}  
\};

void 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 ;  
\}

--------------------

多继承

\#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;R::f();\}  
\};

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();\}  
\};

void 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  
        \}  
\};

void 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;  
\}