【C++之继承和派生、同名隐藏、赋值兼容性规则】

1.面向对象的三大特征： 封装，继承和派生，多态性 封装: 封装:（Encapsulation）是面向对象程序设计最基本的特性，把数据（属性）和函数（方法，操
作）合成一个整体，这在计算机世界中是用类与对象实现的。

继承和派生:（继承和派生一体两面）

继承（inheritance）机制：是类型层次结构设计中实现代码的复用重要手段。
派生：保持原有类特性的基础上进行扩展，增加新属性和新方法，从而产生新的类型。
在面向对象程序设计中，继承和派生是构造出新类型的过程。呈现类型设计的层次结构，体现了程序设计人员对现实世界由简单到复杂的认识过程。

1. 不论采取何种继承方式，基类中所有数据成员都将继承到派生类。

class student : person // 冒号后没有属性默认是私有。
struct student : person // 冒号后没有属性默认是公有。

using namespace std;
class person
{
private:
	int id ;
public:
	 char  name[10];
protected:
	int age;
public:
	person(int x,const char * y,int z):id(x),age(z)
	{	
		strcpy_s(name, strlen(y)+1, y);
		cout << "Create person " << endl;
	}
	~person()
	{}
	void fun()
	{
		cout << "人跳舞" << endl;
	}
	void print()
	{
		cout << "name " <<name<<"age  "<<age << endl;
	}
};
class student  : person  
{
private:
	int id;	
public:
	char name[10];
protected:
	int sex;
public:
	student(int x,const char *  y,int z):person(202207,"ss",22),id(x),sex(z)
	{       
		strcpy_s(name, strlen(y) + 1, y);
		cout << "Create stundet" << endl;
	}
	student() :person(202207, "ss", 22), name(), sex()
	{
		cout << "Create stundet" << endl;
	}
	~student() {}
	void print()
	{
		cout  << "  name :"<<name<<"  sex :" << sex <<"  id : " <<id <<endl;
		cout << "  name :" << person::name << "  age :" << person::age << endl;
		//cout << "person  id :" <
	}
};
int main()
{
	person person1(202201,"yhping",12);
	student student1(202002,"lmy",1);
	student1.print();
}

student(int x,const char * y,int z):person(202207,"ss",22),id(x),sex(z) {} 中基类无名对象person也可以不初始化 :----> person(id,name,age)

3. 在类型的继承层次结构中，保护属性当作公有属性来使用。
4. 继承性具有传递性。
5. 无论采取何种继承方式，派生类对象的成员方法都可以去访问基类对象中的保护和公有属性！！！！！！！！！！！！！！！！！！！！！！！！！！！。

那怎么可以访问基类的私有属性呢？

无论是内部还是外部都需要调动成员方法才能改私有属性。

我们可以通过调动派生类对象的方法，在里面再去调动person类的方法。

class person
{
private:
	int p1 ;
public:
	 char  p2[10];
	 int weight=90;
protected:
	int p3;
public:
	void fun1()
	{
		p1 = 19940811;
		p3 = 180;
	}
	const int& get_p1()const
	{
		return p1;
	}
};
class student : public person
{
private:
	int id;
	person person_one;
public:
	char name[10];
	int  high;
	
protected:
	int sex;
public:
	int get_p1()const
	{
		return id;
	}
	void fun()
	{
		const char* p = "zhangsanfeng";
		person_one.weight = 1000;
		strcpy_s(person::p2, strlen(p) + 1, p);
		person::fun1();//通过fun1()的方法去访问私有属性
		int val=person::get_p1();//通过此方法得到私有属性的值。
		printf("%d", val);
	}
};
int main()
{
	person person1(202201,"yhping",12);
	student student1(202002,"lmy",1,person1);
	student1.high = 180;
	student1.fun();
}

用fun函数初始化基类的person对象（注意不是student类里的基类person）

	student(int x,const char *  y,int z):person(id,name,age),id(x),sex(z)//这里的id，name,age 的是一个变量，不是person的属性！
	{
		strcpy_s(name, strlen(y) + 1, y);
		cout << "Create stundet" << endl;
	}
	void fun()
	{
		//person::id = 2008;
		const char* p = "zhangsanfeng";
		strcpy_s(person::name, strlen(p) + 1, p);
		person::age = 18;
	}

可以看到person类里的公有和保护都可以正常访问。

void fun()
	{
		person::id = 2008;
		const char* p = "zhangsanfeng";
		strcpy_s(person::name, strlen(p) + 1, p);
		person::age = 18;
	}

这里看看能不能访问私有id的属性；（不可访问）

我们把属性换成public试试：（结果还是不能）

---

using namespace std;
class person
{
private:
	int p1 ;
public:
	 char  p2[10];
protected:
	int p3;
public:

};
class student  : public person
{
private:
	int id;
	
public:
	char name[10];
protected:
	int sex;
public:
	void fun()
	{
		//person::p1 = 987654;  //无法访问p1
		const char* p = "zhangsanfeng";
		strcpy_s(person::p2, strlen(p) + 1, p);
		person::p3 = 18;
	}	
};
int main()
{
	person person1(202201,"yhping",12);
	student student1(202002,"lmy",1);
	person1.fun1();
	student1.print();
}

person1内存结构:

student1内存结构:

p1为什么无法访问？

继承来的对象与成员对象的区别(访问控制)

我们准备访问student中基类（person）的保护属性和student类中的对象(person_one)属性中的保护属性( p 3 )，观察是否都能访问。

class person
{
private:
	int p1 ;
public:
	 char  p2[10];
protected:
	int p3;
public:
	person(int x,const char * y,int z):p1(x),p3(z)
	{
		
		strcpy_s(p2, strlen(y)+1, y);
		cout << "Create person " << endl;
	}
	{}
};
class student  : public person
{
private:
	int id;
	
public:
	char name[10];
	person person_one;
protected:
	int sex;
public:
	student(int x,const char *  y,int z,person &s1):person(x,y,z),id(x),sex(z),person_one(s1)
	{
		strcpy_s(name, strlen(y) + 1, y);
		cout << "Create stundet" << endl;
	}

	void print()
	{
		//cout  << "  name2 :"<
		cout << " person继承       p3（保护） :" << p3 << endl;
		cout << " person_one属性   p2(公有） "<<person_one.p2 << endl;
	}
};
int main()
{
	person person1(202201,"yhping",12);
	student student1(202002,"lmy",1,person1);
	student1.print();
}

我们可以看到，继承来的person可以访问保护属性，student类里的person_one成员属性中的公有也可访问。

---

但是唯独student类里的person_one成员属性中的保护和私有是不可访问的。

总结：

1基类的可访问性控制
无论采取何种继承方式，派生类对象的成员方法都可以去访问基类对象中的保护和公有属性。外部 “.”（点）+属性的方式无法访问基类。

2.类类型的可访问性控制
（对于类类型来说，不管其属性是公有私有还是保护，设置的作用是控制外部对其访问的权限。对内部来说，无论采取何种继承方式，保护和私有都是不可访问的。）

3怎么访问私有属性？（不管继承类型是私有和保护都可行）（）
无论是内部还是外部都需要调动成员方法才能改私有属性。

“不管其属性是公有私有还是保护，设置的作用是控制外部对其访问的权限”这句话举个例子：

class person
{
private:
	int p1 ;
public:
	 char  p2[10];
	 int weight=90;
protected:
	int p3;
};
class student : private person
{
private:
	int id;	
public:
	char name[10];
	int  high;
	person person_one;
protected:
	int sex;
	
public:
	student(int x,const char *  y,int z,person &s1):person(x,y,z),id(x),sex(z),person_one(s1)
	{
		strcpy_s(name, 10, y);
		
		cout << "Create stundet" << endl;
	}
	void fun()
	{
		const char* p = "zhangsanfeng";
		printf("%d", person_one.weight);
		
	}
};
int main()
{
	person person1(202201,"yhping",12);
	student student1(202002,"lmy",1,person1);
	student1.fun();
	student1.person_one.weight = 0;//ok
	student1.person_one.p3= -1;//error


}

person_one的属性如果是protected，那么student1.person_one.weight = 0;也是无法通过的。

同名隐藏

3.同名隐藏（成员属性和成员方法）。(就近原则的机制，会调动离自己最近的成员方法。)

using namespace std;

#if 1
class Object
{
public:
	int value;
public:
	Object(int x = 0) :value(x) {}
	~Object() {}
	void print(int x)
	{
		value = x;
		cout << value << endl;
		printf("OBJECT");
	}
};
class Base : public Object
{
public:
	int value;
public:
	Base(int x = 0) : Object(x), value(x + 10) {}
	~Base() {}
	void print()
	{
		value += 10;
		Object::value += 10;
		printf("BASE");
	}
};
int main()
{
	Base base(100);
	base.print();
	//base.Object::print(10);
	
	return 0;
}

结果输出是“BASE”

---

另一种情况：

class Object
{
public:
	int value;
public:
	Object(int x = 0) :value(x) {}
	~Object() {}
	void print(int x)
	{
		value = x;
		cout << value << endl;
		printf("OBJECT");
	}
};
class Base : public Object
{
public:
	int value;
public:
	Base(int x = 0) : Object(x), value(x + 10) {}
	~Base() {}
	void print()
	{
		value += 9;
		Object::value += 10;
		printf("BASE");
	}
};
int main()
{
	Base base(100);
	base.print(10);//error 
	return 0;
}

我们想进行函数的重载那样进行类同名方法的重载，可现实确不被允许。
想调用基类的方法可以这样：base.Object::print(10)；

赋值兼容性规则

C++面向对象编程中一条重要的规则是：公有继承意味着 “是一个” 。一定要牢牢记住这条规则。
1.赋值的切片

派生类的对象可以赋值给基类的对象，这时是把派生类对象中从对应基类中继承来的隐藏对象赋值 给基类对象。反过来不行，因为派生类的新成员无值可赋。


基类object 受保护，不能对其赋值，不能将地址赋
注意：赋值性规则2条：只能把子给给父 2.只能是公有类型！

class Object
{
public:
	int value;
public:
	Object(int x ) :value(x) {}
	~Object() {}
	void print()
	{
		cout <<"OBJECT"<< value << endl;
	}
};
class Base : public Object
{
public:
	int num;
public:
	Base(int x = 0) : Object(x), num(x + 10) {}
	~Base() {}
	void print()
	{
		cout << "base.value"<<value << endl;	
	}
};
int main()
{
	Base base(100);
	Object object(1000);
	//object = base;//切片现象。
	object.print();
	base.print();
	return 0;
}

而赋值会产生切片现象，即把基类的属性值赋值给基类对象的属性值。而子对象派生的属性不会赋值出去。

举个例子，人对象和学生对象，学生是人，人不一定是学生。从世界实际来说父赋值给子是不成立的。第二，新派生的值没有办法给。

2.传地址和引用的切片
问：类型对指针的约束能力？

1.指针加一的能力 ，2。指针解析的能力

Base base(100);
	Object object(1000);
	Object* p = &base;
	Object& ip = base;
	ip.value = 999;
	cout << ip.value << endl;
	return 0;

看看两个对像的大小：

Object* p = &base; // obj在解引用时只能解析到看到的4字节空间，所以解析不到base 派生的num的值。