第十二章继承

// 4 单一继承
/*
#include <iostream>
using namespace std;
class fatcher
{
private:
	int height, width;
public:
	void setHeight(int h){ this->height = h; }
	void setWidth(int w){ this->width = w; }
	void show()
	{
	   cout<<"身高="<<height<<" 体重="<<width<<endl;
	}
};

class sun : public fatcher
{
private:
	int sunJK, sunPC;
public:
	void setSunJK(int j){ this->sunJK = j;}
	void setSunPC(int j){ this->sunPC = j;}
	void showSun(){ cout<<"JK:"<<sunJK<<" PC:"<<sunPC<<endl;}
};

int main()
{
	sun a;
	a.setHeight(170);
	a.setWidth(50);
	a.setSunJK(100);
	a.setSunPC(200);
	a.show();
	a.showSun();
    return 0;
}*/


//5 公有型 保护型和私有型
/*
#include <iostream>
using namespace std;
class fatcher
{
//private:
protected:
	int height, width;
public:
	void setHeight(int h){ this->height = h; }
	void setWidth(int w){ this->width = w; }
	void show()
	{
	   cout<<"身高="<<height<<" 体重="<<width<<endl;
	}
};

class sun : public fatcher
{
private:
	int sunJK, sunPC;
public:
	void setSunJK(int j){ this->sunJK = j;}
	void setSunPC(int j){ this->sunPC = j;}
	//void showSun(){ cout<<"JK:"<<sunJK<<" PC:"<<sunPC<<endl;}
	void show(){ 
	cout<<"身高="<<height<<" 体重="<<width<<endl;
	cout<<"JK:"<<sunJK<<" PC:"<<sunPC<<endl;}
};

int main()
{
	sun a;
	a.setHeight(170);
	a.setWidth(50);
	a.setSunJK(100);
	a.setSunPC(200);
	a.show();
	//a.showSun();
    return 0;
}*/

//6 公有派生的公有成员
/*
#include <iostream>
using namespace std;
class fatcher
{
public:
	void root(){ cout<<"父亲的大房子我也可以享受"<<endl;}
};

//公有继承对父类的公有属性，就像自己的一样，可以随便用
class son:public fatcher
{
    
};
int main()
{
	son s;
	s.root();
	return 0;
}*/

// 7 公有派生的保护成员
/*
#include <iostream>
using namespace std;
class fatcher
{
protected:
	void room(){ cout<<"父亲的大房子我也可以享受"<<endl;}
};

//公有继承对父类的公有属性，就像自己的一样，可以随便用
//公有继承对像，父类的保护成员在子类中也是保护成员
class son:public fatcher
{
public:
	void enjoy(){ room(); } //只能通过公用的接口来访问父类的保护成员room()

};
int main()
{
	son s;
	//s.root(); //无法访问保护成员
	s.enjoy();
	return 0;
}*/

//8 公有派生的私有成员
/*#include <iostream>
using namespace std;
class fatcher
{
protected:
	void room(){ cout<<"父亲的大房子我也可以享受"<<endl;}
private:
	void secret(){ cout<<"父亲的密秘"<<endl;}
};

//公有继承对父类的公有属性，就像自己的一样，可以随便用
//公有继承对像，父类的保护成员在子类中也是保护成员
class son:public fatcher
{
public:
	void enjoy(){ 
	   room(); 
	   //secret();  不能访问你类的私有成员
	} //只能通过公用的接口来访问父类的保护成员room()

};
int main()
{
	son s;
	//s.root(); //无法访问保护成员
	s.enjoy();
	return 0;
}*/

//公有派生的赋值问题
/*
#include <iostream>
using namespace std;
class father
{
public:
	int x;
	void show(){ cout<<"x:"<<x<<endl;}
};
class son : public father
{
public:
	int y;
};
int main()
{*/
	/*father Nick;
	son Jack;
	Jack.y = 11;
	Jack.x = 22;
	Jack.show();

	Nick = Jack; //这里可以将子类的对像赋值给父类，但不能把你类的对像赋值给子类

	Nick.show();*/

	/*father *p;
	son Jack;
	p = &Jack;
	p->x = 3;
	cout<<p->x<<endl;*/
/*
	son Jack;
	father &Nick = Jack;


    return 0;
}*/

// 私有派生
/*
#include <iostream>
using namespace std;
class father
{
public:
	void room(){cout<<"父亲的大房子我可以享受"<<endl;}
};
//私有继承
//class son: private father
//保护继承
class son: protected father
{
public:
	void enjoy(){room();}
};
int main()
{
	son a;
	a.enjoy();
	return 0;
}*/

// 11 多重继承
/*
#include <iostream>
using namespace std;

class father
{
public:
	void setA(int a){toll = a;}
	void printA(){ cout<<"身高:"<<toll<<endl;}
private:
	int toll;
};

class mother
{
private:
	int weight;
public:
	void setB(int w){ weight = w;}
	void printB(){ cout<<"体重"<<weight<<endl;}
};

//class son: public father, public mother
class son: public father, private mother 
//以私有方式继承后，基类的私有成员变成不可访问，而公有成员和保护成员也变成了私有，派生类中的成员想要访问他们必须定义一个公有函数作为接口

{
private:
	int age;
public:
	void setC(int a){ age = a;}
	void setb(int b){ setB(b);} //必须定义一个公有的接口来访问私有成员,两个成员不可访问的问题
	void printC(){
		printA();
		printB();
		cout<<"年龄:"<<age<<endl;
	}
};

int main()
{
	son s;
	s.setA(170);
	//s.setB(50);
	s.setb(50);
	s.setC(23);
	s.printC();
    return 0;
}*/

//12 继承和构造与析构
/*
#include <iostream>
using namespace std;
class father
{
private:
	int a;
public:
	father(int i){ a= i; cout<<"构造基类a的值:"<<a<<endl;}
	~father(){ cout<<"析构基类a的值"<<a<<endl;}
};
class son: public father
{
private:
	int b;
public:
	son(int i, int j);
	~son(){cout<<"析构子类b的值:"<<b<<endl;}
};
son::son(int i, int j):father(i)
{
	b = j;
	cout<<"构造子类的b的值:"<<b<<endl;
};
int main()
{
	son a(11,22);

    return 0;
}*/
//构造和析构的顺序
//先构造父类的构造函数，然后构造子类的构造函数
//先析构子类的析构函数，然后析构父类的析构函数

// 向基类构造函数传递参数
/*
#include <iostream>
#include <string>
using namespace std;
class father
{
protected:
	string name;
	int tall;
public:
	father(string a, int i){ name=a, tall=i; cout<<"执行带两个参数的基类对像"<<endl; };
	father(){cout<<"构造基类"<<endl;}
	//这里是输出字符串的
	void print(){cout<<" 身高为:"<<tall<<" Name:"<<name<<endl;}
	~father(){cout<<"释放基类对像"<<endl;}
};*/

/*
father::father(string a, int i)
{
	cout<<"\n 在基类的构造函数内\n";
	name = a;
	tall = i;
	print();
	cout<<"离开基类构造函数"<<endl;
};*/

/*
class son:public father
{
private:
	int weight;
public:
	son(string a, int i, int j);
	void print1();
	~son(){cout<<"离开子类对像"<<endl;}
};
son::son(string a, int i, int j):father(a, i)
{
	//name = a;
	//tall = i;
	weight = j;
	cout<<"在子类的构造函数内"<<endl;
};
void son::print1()
{
	father::print();
	cout<<"体重:"<<weight<<endl;
}

int main()
{
	son Make("Mike",180,77);
	Make.print1();
	cout<<"程序执行完成"<<endl;
    return 0;
}*/

// 向基类构造函数传递参数
/*
#include <iostream>
#include <string>
using namespace std;
class father
{
protected:
	string name;
	int tall;
public:
	father(string a, int i);
	father(){cout<<"构造基类"<<endl;}
	//这里是输出字符串的
	void print(){cout<<" 身高为:"<<tall<<" Name:"<<name<<endl;}
	~father(){cout<<"释放基类对像"<<endl;}
};

father::father(string a, int i)
{
	cout<<"\n 在基类的构造函数内\n";
	name = a;
	tall = i;
	print();
	cout<<"离开基类构造函数"<<endl;
};

class son:public father
{
private:
	int weight;
public:
	son(string a, int i, int j);
	void print1();
	~son(){cout<<"离开子类对像"<<endl;}
};
son::son(string a, int i, int j)
{
	name = a;
	tall = i;
	weight = j;
	cout<<"在子类的构造函数内"<<endl;
};
void son::print1()
{
	father::print();
	cout<<"体重:"<<weight<<endl;
}

int main()
{
	son Make("Mike",180,77);
	Make.print1();
	cout<<"程序执行完成"<<endl;
    return 0;
}
*/

//多重继承容易产生两义性
/*
#include <iostream>
using namespace std;
class A
{
public:
	void hello(){cout<<"基类A的hello函数"<<endl;}
};
class B
{
public:
	void hello(){cout<<"基类B的hello函数"<<endl;}
};

class C : public A, public B
{
public:
	void hello(){cout<<"基类C的hello函数"<<endl;}
};


int main()
{
	C c;
	c.hello(); //这里多重继承容易产生两义性
    c.A::hello(); //这里可以去掉两义性
	c.B::hello();


    return 0;
}
*/

//15 继承中的重载
/*
#include <iostream>
using namespace std;
class father
{
public:
	void hello(){cout<<"基类的事带参数的hello函数"<<endl;}
	void hello(int i){ cout<<"基类的带一个参数hello函数"<<endl;}
};
class son:public father
{
public:
	void hello(){cout<<"子类的事带参数的hello函数"<<endl;}
	//当我们在子类中定义一个与基类同名的函数时，那么等于是告诉编译器，用子类的函数覆盖掉基类的同名函数，同时将它重载函数隐藏起来.
	
	void hello()const{cout<<"子类的事带参数的const hello函数"<<endl;}
	//这里与hello()函数是不一样的，因为hello()const函数只能被const对像所调用


	void hello(int i){ cout<<"子类的带一个参数hello函数"<<endl;}
};
int main()
{
    son s;
	s.hello();
	//s.hello(2); //将不能再访问了
	
	const son ss;
	ss.hello();

	return 0;
}*/


/*
#include <iostream>
using namespace std;
class A
{
public:
	void hello(){cout<<"基类A的hello函数"<<endl;}
	void hello(int i)
	{
	    cout<<"a.hello(i):"<<i<<endl;
		cout<<"基类a的带一个参数的hello函数"<<endl;
	}
};
class B : public A
{
public:
	//void hello(){ cout<<"子类b的hello函数"<<endl;}
	//还是一种方法是添加const,这样就不会把父类的函数隐藏起来了
	void hello()const{  cout<<"子类b的hello函数"<<endl;}
	void hello(int i)const{
		    cout<<"b.hello(i):"<<i<<endl;
		    cout<<"子类B的带一个参数的hello函数"<<endl;
	}
};

int main()
{
	B b;
	b.hello();
	b.hello(11);


	//b.hello(11); //把带参的重载函数会是被隐藏起来了
	//b.A::hello(11); //呵呵，这样也行，不握你隐藏起来
    return 0;
}*/

// 16 两义性的归属问题

//一个派生类从多个基类派生，而这些基类双有一个共同的基类，那么在派生类中访问共同的基类中的成员时会产生两义性
/*
#include <iostream>
using namespace std;
class Human
{
public:
	void stand(){cout<<"人类能够直立行走"<<endl;}
};

class father: public Human
{

};
class mother: public Human
{

};
class son : public father, public mother
{

};
int main()
{
	son s;
	//s.stand();//两义性的归属问题
	s.mother::stand();
    return 0;

}*/


//17 虚基类不会产生两义性
/*
#include <iostream>
using namespace std;

#include <iostream>
using namespace std;
class Human
{
public:
	void stand(){cout<<"人类能够直立行走"<<endl;}
};
//virtual 声明为虚基类
class father:virtual public Human
{

};
class mother:virtual public Human
{

};
class son : public father, public mother
{

};
int main()
{
	son s;
	//s.stand();//两义性的归属问题
	//s.mother::stand();
	s.stand();
	return 0;

};*/


#include <iostream>
using namespace std;

#include <iostream>
using namespace std;
class Human
{
public:
	void stand(){cout<<"人类能够直立行走"<<endl;}
};
//virtual 声明为虚基类
class father:virtual public Human
{
public:

	void stand(){cout<<"父类能够直立行走"<<endl;}
};
class mother:virtual public Human
{
public:

	void stand(){cout<<"母类能够直立行走"<<endl;}
};
class son : public father, public mother
{
public:
void stand(){cout<<"子类能够直立行走"<<endl;}

};
int main()
{
	son s;
	s.stand();

	father f;
	f.stand();

	mother m;
	m.stand();

	Human h;
	h.stand();
	return 0;
};