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-axispublic: 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 firstC(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 pointostream & operator <<(ostream & os, Circle & aCircle){cout<< "Circle:radius:" << aCircle.radius;os<< aCircle.x << "/n"; os<< aCircle.y << "/n"; return os; }
// THE CYLINDER CLASSclass 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 areareturn 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 classdouble 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 Pointclass 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 pointostream & 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 castcout <<"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;}
本文来自博客，转载请标明出处：http://blog.csdn.net/zhaori/archive/2007/07/20/1700356.aspx
