继承的概念、一些基础的语法与类型兼容性原则（基础）

程序员之间的类继承图。。（打个比方）

其实，继承就是某一种类与类之间的关系，派生类（子类）中可以继承基类（父类）中的某些属性

无论是下面哪一种继承，子类都无法访问或继承父类中的私有属性（private永远是private）

protect成员比较特殊，可以在子类中进行访问，但无法被外界访问（可以类比成父亲的银行卡密码，你可以继承，但不能给别人）

1. public 继承：原来父类中的（public 和 protect）成员在子类中不变，也就是子类一点不变地继承了父类中所有的（public  protect）成员

2. protect 继承：原来父类中的（public 和 protect）成员在子类中都变成了protect成员

3. private 继承：原来父类中的成员都变成了private成员

单个类的访问控制

#include <iostream>
using namespace std;

//public 修饰的成员变量 方法 在类的内部 类的外部都能使用
//protected: 修饰的成员变量方法,在类的内部使用 ,在继承的子类中可用 ;其他 类的外部不能被使用
//private: 修饰的成员变量方法 只能在类的内部使用 不能在类的外部

//派生类访问控制的结论
//1 protected 关键字 修饰的成员变量 和成员函数 ,是为了在家族中使用 ,是为了继承
//2 项目开发中 一般情况下 是 public
//3


class Parent
{
public:
			int a; //老爹的名字
protected:
			int b; //老爹的银行密码
private:
			int c; //老的情人
};


//保护继承
class Child3 : protected Parent
{
public:
protected:
private:
public:	
	void useVar()
	{
		a = 0; // ok
		b = 0; // ok //b这这里 写在了子类Child3的内部  2看protected 3密码===>protected
		//c = 0; //err
	}
};

void main()
{
	Child3 c3;
	//c3.a = 10; //err
	//c3.b = 20; //err
	//c3.c = 30;//err

}



//私有继承
class Child2 : private Parent
{
public:
	void useVar()
	{
		a = 0; //ok
		b = 0; //ok
		//c = 0; // err
	}

protected:
private:
};

void main22()
{
	Child2 c2;
	//c1.a = 10; err
	//c2.b = 20; err
	//c3.b = 30;
}



class Child : public Parent
{
public:
	void useVar()
	{
		a = 0; //ok
		b = 0; //ok
		//c = 0; // err
	}

protected:
private:
};


/*
C++中的继承方式（public、private、protected）会影响子类的对外访问属性	
	判断某一句话，能否被访问
	1）看调用语句，这句话写在子类的内部、外部
	2）看子类如何从父类继承（public、private、protected）	
	3）看父类中的访问级别（public、private、protected）
*/
//共有继承 
void main()
{
	Parent t1, t2;
	t1.a  = 10; //ok
	//t1.b = 20; //err
	//t2.c = 30 ; //err
	
	cout<<"hello..."<<endl;
	return 0;
}

派生类访问控制综合训练

//类的继承方式对子类对外访问属性影响

#include <cstdlib>
#include <iostream>

using namespace std;

class A
{
private:
	int a;
protected:
	int b;
public:
	int c;

	A()
	{
		a = 0;		b = 0;		c = 0;
	}

	void set(int a, int b, int c)
	{
		this->a = a;		this->b = b;		this->c = c;
	}
};
class B : public A
{
public:
	void print()
	{
		//cout<<"a = "<<a; //err
		cout<<"b = "<<b; //ok
		cout<<"c = "<<endl; //ok
	}
};

class C : protected A
{
public:
	void print()
	{
		//cout<<"a = "<<a; //err
		cout<<"b = "<<b; // ok
		cout<<"c = "<<endl; //ok
	}
};

class D : private A
{
public:
	void print()
	{
		//cout<<"a = "<<a; //err
		cout<<"b = "<<b<<endl;  //ok
		cout<<"c = "<<c<<endl; // ok
	}
};

int main()
{
	
	A aa;
	B bb;
	C cc;
	D dd;

	aa.c = 100;  //ok
	bb.c = 100; // ok
	//cc.c = 100; // err 保护的
	//dd.c = 100;  // err
	
	aa.set(1, 2, 3); //ok
	bb.set(10, 20, 30); //ok
	//cc.set(40, 50, 60); // err
	//dd.set(70, 80, 90);  //err
	

	bb.print(); //ok
	cc.print(); //ok
	dd.print(); //


	/**/
	return 0;
}

类型兼容性原则

类型兼容规则是指在需要基类对象的任何地方都，都可以使用公有派生类对象来替代。通过公有继承，得到了基类中除构造函数和析构函数外的所有成员。这样，公有派生类实际上就具备了基类的所有功能，凡是基类能解决的问题，共有派生类都可以解决。类型兼容规则中所指的替代包括以下情况：

1.子类对象可以当父类对象使用

2.子类对象可以直接赋值给父类对象

3.子类对象可以直接初始化父类对象

4.父类指针可以直接指向子类对象

5.父类引用可以直接引用子类对象

总结：子类就是特殊的父类

#include <iostream>
using namespace std;

class Parent
{
public:
	void printP()
	{
		cout<<"我是爹..."<<endl;
	}

	Parent()
	{
		cout<<"parent构造函数"<<endl;
	}

	Parent(const Parent &obj)
	{
		cout<<"copy构造函数"<<endl;
	}

private:
	int a;
};

class child : public Parent
{
public:
	void printC()
	{
		cout<<"我是儿子"<<endl;
	}
protected:
private:
	int c;
};



/*
兼容规则中所指的替代包括以下情况：
	子类对象可以当作父类对象使用
	子类对象可以直接赋值给父类对象
	子类对象可以直接初始化父类对象
	父类指针可以直接指向子类对象
	父类引用可以直接引用子类对象
	*/



//C++编译器 是不会报错的 .....
void howToPrint(Parent *base)
{
	base->printP(); //父类的 成员函数

}

void howToPrint2(Parent &base)
{
	base.printP(); //父类的 成员函数
}
int main()
{
	//

	Parent p1;
	p1.printP();

	child c1;
	c1.printC();
	c1.printP();


	//赋值兼容性原则
	//1-1 基类指针 (引用) 指向 子类对象
	Parent *p = NULL;
	p = &c1;
	p->printP();

	//1-2 指针做函数参数

	howToPrint(&p1);
	howToPrint(&c1);

	//1-3引用做函数参数
	howToPrint2(p1);
	howToPrint2(c1);


	//第二层含义

	//可以让子类对象   初始化   父类对象
	//子类就是一种特殊的父类
	Parent p3 = c1;


	cout<<"hello..."<<endl;
	return 0;
}