c++继承实例（转载）

原文地址：http://blog.csdn.net/zhaori/article/details/1700356

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