类的继承方式对子类对外访问属性影响,赋值兼容性原则

关于继承概念

C++中的继承方式（public、private、protected）会影响子类的对外访问属性

 3个步奏搞定
判断某一句话，能否被访问
1）看调用语句，这句话写在子类的内部、外部
2）看子类如何从父类继承（public、private、protected）
3）看父类中的访问级别（public、private、protected）

综合练习

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

#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; //0k
		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;  //看这句话写在了D类的内部 
		cout<<"c = "<<c<<endl; 
	}
};

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


	bb.print();
	cc.print();
	dd.print();
	
		/**/
	system("pause");
	return 0;
}

总结：不同的继承方式可能改变继承成员的访问属性
练习：
public继承不会改变父类对外访问属性；
private继承会改变父类对外访问属性为private；
protected继承会部分改变父类对外访问属性。

赋值兼容性原则

子类对象可以当作父类对象使用

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

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

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

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

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

</pre><pre name="code" class="cpp">#include<iostream>

class Parent
{
public:
	void printP()
	{
		std::cout << "我是爹" << std::endl;
	}
protected:
	int a, b;
private:
};
class Child:public Parent
{
public:
	Child()
	{
		a = b = c = 0;
	}
	void printC()
	{
		std::cout << "我是儿子" << std::endl;
	}
protected:
private:
	int c;
};
void howtoPrint(Parent*p)
{
	p->printP();
}
void howtoPrint(Parent&p)
{
	p.printP();
}

void main()
{
	Parent p1;
	p1.printP();
	Child c1;//
	c1.printC();
	Parent *base = NULL;//父类指针
	//可以把子类对象赋值给基类指针
	//子类就是一种特殊的父类
	base = &c1;
	base->printP();

	Parent&myp = c1;//父类的引用引用子类
	myp.printP();

	//测试j基类指针做函数参数
	howtoPrint(&p1);
	howtoPrint(&c1);

	//测试父类引用做函数参数
	howtoPrint(p1);
	howtoPrint(c1);

	Parent p3 = c1;//子类直接初始化父类
	Parent p4;
	p4 = c1;


	system("pause");
}