构造函数访问权限和基类构造函数，派生类的构造函数调用顺序

#include<iostream>
#include<stdlib.h>
using namespace std;
//1.访问权限
class B
{
public:
	void Fun1(int b1,int b2,int b3)
	{
		_b1=b2;
		_b2=b2;
		_b3=b3;

	}
public:
	int _b1;
protected:
	int _b2;
private:
	int _b3;
};
class C:private B
{
public:
	 void Fun2()
	{
		_b1=1;
		_b2=2;
		_b3=3;//不可以访问,private继承下来了，但是不可以访问，不可见
	}
public:
	int _c1;
protected:
	int _c2;
private:
	int _c3;
};
class D:protected C
{
public:
	void Fun3()
	{
		_b1=1;
		_b2=2;
		_b3=3;
	}

public:
	int _d1;
protected:
	int _d2;
private:
	int _d3;
};
//2.构造函数的调用顺序
//a.基类没有缺省的构造函数，必须在派生类的初始化列表中显示给出基类类名和参数列表
class B
{
public:
	B(int b)
	{cout<<"B()"<<endl;};
private:
	int _b;
}
class C1:public B
{
	C1(int c1)
		:B(c1)
	{cout<<"C1()"<<endl;}
private:
	int _c1;
};

//b.基类有带参的构造函数，派生类一定要定义构造函数.
class B
{
public:
	B(int b)
	{cout<<"B()"<<endl;};
private:
	int _b;
};
class C1:public B
{
	/*C1(int c1)
	{cout<<"C1()"<<endl;}*/
private:
	int _c1;
};
void main()
{
	C1 c1;
	system("pause");
}
//c.构造谁的对象就调用谁，在参数列表先实现基类的构造函数（按继承顺序）,再到派生类中成员对象（按声明顺序），最后实现自己的构造函数
class B
{
public:
	B()
	{cout<<"B()"<<endl;};
private:
	int _b;
};
class A
{
public:
	A()
	{cout<<"A()"<<endl;};
private:
	int _a;
};
class C1
{
public:
	C1()
	{cout<<"C1()"<<endl;}
private:
	int _c1;
};
class D:public C1,public B
{
public:
	D()
	{cout<<"D()"<<endl;};
private:
	int _d;
	B b;
	C1 c1;
	A a;

};
void main()
{
	D d;
	system("pause");
}

同名隐藏就是基类的成员变量或成员函数名字(无论你什么类型，或者参数列表不同，只要名字相同)和派生类一样时，派生类会覆盖基类的。
#include<iostream>
#include<stdlib.h>
using namespace std;
class B
{
public:
	void func1(int b)
	{
		cout<<"func1"<<endl;
	}
	
public:
	char* a;
};
class C1:public B
{
public:
	void func1(int c1,int c2)
	{
		cout<<"func1"<<endl;
	}
public:
	int a;
	
	
}
void main()
{
	C1 c1;
	c1.func1(2);//错，基类已覆盖
	c1.B::func1(2);//对
	c1.func1(2,3);
	c1.a="hello";//错，基类已覆盖
	c1.B::a="hello"//对

}