一个派生的简单例子

1、

#include <iostream>
using namespace std;
class A
{
private:
	int x;
protected:
	int y;
public:
	int z;
	void setx(int i)
	{
		x=i;
	}
	int getx()
	{
		return x;
	}
};

class B:public A
{
private:
	int m;
protected:
	int n;
public:
	int p;
	void setvalue(int a,int b,int c,int d,int e,int f)
	{
		setx(a);
		y=b;
		z=c;
		m=d;
		n=e;
		p=f;
	}
	void display()
	{
		cout<<"x="<<getx()<<endl;
//		cout<<"x="<<x<<endl;//基类中x为私有变量，派生类中成员函数不能直接访问
		cout<<"y="<<y<<endl;//基类中y为保护变量，派生类中成员函数可以直接访问
		cout<<"m="<<m<<endl;
		cout<<"n="<<n<<endl;
	}
};

int main()
{
	B obj;
	obj.setvalue(1,2,3,4,5,6);
	obj.display();
	//cout<<"y="<<obj.y<<endl;基类中y为保护变量，派生类的对象不能直接访问
	cout<<"z="<<obj.z<<endl;
	cout<<"p="<<obj.p<<endl;
	return 0;
}

 

2、私有继承

/*
#include <iostream>
using namespace std;
class A
{
private:
	int x;
protected:
	int y;
public:
	int z;
	void setx(int i)
	{
		x=i;
	}
	int getx()
	{
		return x;
	}
};

class B:public A
{
private:
	int m;
protected:
	int n;
public:
	int p;
	void setvalue(int a,int b,int c,int d,int e,int f)
	{
		setx(a);
		y=b;
		z=c;
		m=d;
		n=e;
		p=f;
	}
	void display()
	{
		cout<<"x="<<getx()<<endl;
//		cout<<"x="<<x<<endl;//基类中x为私有变量，派生类中成员函数不能直接访问
		cout<<"y="<<y<<endl;//基类中y为保护变量，派生类中成员函数可以直接访问
		cout<<"m="<<m<<endl;
		cout<<"n="<<n<<endl;
	}
};

int main()
{
	B obj;
	obj.setvalue(1,2,3,4,5,6);
	obj.display();
	//cout<<"y="<<obj.y<<endl;基类中y为保护变量，派生类的对象不能直接访问
	cout<<"z="<<obj.z<<endl;
	cout<<"p="<<obj.p<<endl;
	return 0;
}
*/


//私有继承基类的protected和public成员在派生类中均为private
#include <iostream>
using namespace std;
class A
{
private:
	int x;
protected:
	int y;
public:
	int z;
	void setx(int i)
	{
		x=i;
	}
	int getx()
	{
		return x;
	}
};

class B:private A
{
private:
	int m;
protected:
	int n;
public:
	int p;
	void setvalue(int a,int b,int c,int d,int e,int f)
	{
		setx(a);
		y=b;
		z=c;
		m=d;
		n=e;
		p=f;
	}
	void display()
	{
		cout<<"x="<<getx()<<endl;
	//	cout<<"x="<<x<<endl;//基类中x为私有变量，派生类中成员函数不能直接访问
		cout<<"y="<<y<<endl;//基类中y为保护变量，派生类中变为私有变量，派生类中的函数可以直接访问
		cout<<"m="<<m<<endl;
		cout<<"n="<<n<<endl;
	}
};

int main()
{
	B obj;
	obj.setvalue(1,2,3,4,5,6);
	obj.display();
	//cout<<"y="<<obj.y<<endl; //基类中y为保护变量，派生类的对象不可以直接访问
	//cout<<"z="<<obj.z<<endl; //在通过继承变为私有成员，派生类的对象不可以直接访问
	cout<<"p="<<obj.p<<endl;
	return 0;
}

 

3、保护继承

#include <iostream>
using namespace std;
class pet
{
public:
	void speak()
	{
		cout<<"How does a pet speak!"<<endl;
	}
};

class cat:public pet
{
public:
	void speak()
	{
		cout<<"miao!miao!"<<endl;
	}
};

class dog:public pet
{
public:
	void speak()
	{
		cout<<"wang!wang!"<<endl;
	}
};

int main()
{
	pet *p1,*p2,*p3,obj;
	dog dog1;
	cat cat1;
	obj = dog1;//派生类的对象可以复制给基类对象
	obj.speak();//派生类作为基类使用，只能使用基类里成员函数

	p1 = &cat1;//派生类的对象的地址可以复制给基类对象指针
	p1->speak();//派生类对象作为基类使用，只能使用基类里的成员函数

	p1 = &dog1;//派生类的对象的地址可以复制给基类对象指针
	p1->speak();

	p2 = new cat;//派生类对象作为基类使用，只能使用基类里的成员函数
	p2->speak();
	
	p3 = new dog;//派生类的对象的地址可以复制给基类对象指针 
	p3->speak();//派生类对象作为基类使用，只能使用基类里的成员函数

	pet &p4 = cat1;//派生类对象可以初始化基类的引用
	p4.speak();//派生类对象作为基类使用，只能使用基类里的成员函数

	dog1.speak();
	cat1.speak();

	return 0;
}