C++中的继承

继承的写法class child:（private，public，protected）parent.和Java一样，访问机制。

C++中的继承方式会影响子类的对外访问属性

public继承：父类成员在子类中保持原有访问级别

private继承：父类成员在子类中变为private成员

protected继承：父类中public成员会变成protected

  父类中protected成员仍然为protected

  父类中private成员仍然为private

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

判断某一句话，能否被访问

1）看调用语句，这句话写在子类的内部、外部

2）看子类如何从父类继承（public、private、protected）

3）看父类中的访问级别（public、private、protected）

parent *p=null.p=&child1,p->printchild(

#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>

using namespace std;

/*
子类对象可以当作父类对象使用
子类对象可以直接赋值给父类对象
子类对象可以直接初始化父类对象
父类指针可以直接指向子类对象
父类引用可以直接引用子类对象
*/

class Parent
{
public:
	void printP()
	{
		cout << "Parent::printP()..." << endl;
	}
	int a;
};

class Child :public Parent
{
public:
	void printC()
	{
		cout << "Child:: printC()...." << endl;
	}
	int b;
};

void print(Parent *p)
{
	p->printP();
}

int main(void)
{
	Child c;//子类对象
	c.printP(); //子类对象可以当作父类对象使用

	Parent p = c; // 由于子类拥有全部父类的内存空间，子类能够保障父类初始化完整。
						 //子类对象可以直接初始化父类对象 因为子类内存空间包容的父类的，能够保证
						// 完全赋值。
	//Child c2 = p;

	
	//父类指针可以直接指向子类对象
	//子类对象能够完全满足父类指针的需求，所以可以  父类指针可以直接指向子类对象
	Parent *pp = &c;  //pp->printP   (x ) pp->printC
	//pp->printC();
	pp->a;

	//不能用子类指针指向父类对象。
	//父类对象满足不了子类指针的所有需求， 所以不能够 子类指针指向父类对象。
	//Child *cp = &p; // cp-> printP,  cp->printC
	//cp->b; //p中没有b的内存。 //此时访问b就越界了。
	//cp->printP();
	//cp->printC();

	//父类引用可以引用子类对象
	Parent &pr = c;

	//子类引用不可以引用父类的对象。
	//Child &cr = p;

	print(&p); //Parent* p = &p;

	print(&c); //Parent *p = &c;

	//父类指针可以指向子类对象。 

	return 0;
}

);父类引用指向子类对象，Java的多肽

父类与子类的初始化代码

#include <iostream>

using namespace std;
//先调用父类的构造，再子类，再子类析构再父类析构 
class object{
public :
	int a;
public :
	object(int a){
		this->a=a;
		cout<<"我是obejct构造函数"<<endl; 
	}
	~object(){
		cout<<"我是obeject析构函数"<<endl;
	}
	
		
	
}; 
class parent:public object{
public :
	int a;
public :
	parent(int a):object(20){
		this->a=a;
		cout<<"我是Parent构造函数"<<endl; 
	}
	~parent(){
		cout<<"我是Parent析构函数"<<endl;
	}
	void print(){
		cout<<"我是测试"<<endl;
	} 
};
class  child:public parent{
	
public :
	int b;
	object obj;
	
public :
	child(int b):parent(20),obj(60){//之前去除了：后面的报错，是因为父类没有初始化，必须想方设法让父类初始化 obj那前面必须是逗号
		this->b=b;
			cout<<"我是child构造函数"<<endl; 
	}
    ~child() {
    		cout<<"我是child析构函数"<<endl;
	}
};

int main(){
	
	child ca(20);
	ca.print();
}

  先构造父类，再构造成员变量、最后构造自己

  先析构自己，在析构成员变量、最后析构父类

#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>

using namespace std;

class Parent
{
public:
	Parent(int a)
	{
		this->a = a;
	}

	int a;
};

class Child :public Parent
{
public :
	Child(int a, int aa) : Parent(aa)
	{
		this->a = a; //让Child 的a  = a， 让父亲的a = aa
	}

	void print()
	{
		cout << "a = " << a << endl; //默认是使用 当前类的重名的变量
		cout << "Parent::a = " << Parent::a << endl;  //如果想访问父类中的重名变量 需要加上父类的作用域
	} 

	int a;
	/*
	  a ---> Paretn::a
	*/
};

int main(void)
{
	Child c(10, 100);

	c.print();
	
	return 0;
}

当子类的成员变量与父类的相同时。默认调用的子类，可用parent：：a调用父类。当出现多继承的两个类来自同一个父类，在调用父类参数时编译器不知道调用哪一个采用虚继承。