c++ 基础知识-类和对象-继承2

1.c++ 基础知识-类和对象-继承-构造和析构顺序

#include <iostream>  
#include <string>    
using namespace std;
//继承
// 基类 父类 包含一些公共或者说可以重复利用的内容
class Base
{
public:
	Base();
	~Base();
};

Base::Base()
{
	cout<<"Base()：构造函数"<<endl;
}
Base::~Base()
{
	cout<<"Base()：析构函数"<<endl;
}
//公共继承 public
class A:public Base
{
public:
	A();
	~A();
};
A::A()
{
	cout<<"A()：构造函数"<<endl;
}
A::~A()
{
	cout<<"A()：析构函数"<<endl;
}
void fun_A()
{
	A a;
}
int main()
{
	fun_A();
	//输出:
	//Base()：构造函数
	//A()：构造函数
	//A()：析构函数
	//Base()：析构函数
	return 0;
}  

2.c++ 基础知识-类和对象-继承-同名成员处理

#include <iostream>  
#include <string>  
using namespace std;

//继承
// 基类 父类 包含一些公共或者说可以重复利用的内容
class Base
{
public:
	Base();
	
	void fun();

	void fun(int n);
	int m_A;
};

Base::Base()
{
	m_A = 2000;
}

void Base::fun()
{
	cout<<"Base : fun()"<<endl;
}

void Base::fun(int n)
{
	cout<<"n = "<<n<<endl;
	cout<<"Base:fun(int n)"<<endl;
}

//公共继承 public
class A:public Base
{
public:
	A();
	void fun();
	int m_A;
};

A::A()
{
	m_A = 100;
}
void A::fun()
{
	cout<<"A : fun()"<<endl;
}

void fun_A()
{
	A a;
	cout<<a.m_A<<endl;//默认访问的都是子类成员变量
	cout<<a.Base::m_A<<endl;//访问父类成员变量需要用作用域
	a.fun();//默认访问的都是子类成员函数
	a.Base::fun();//访问父类成员函数需要用作用域
	//a.fun(4);//error C2660: “A::fun”: 函数不接受 1 个参数 //同名函数只能访问子类中的，不是重载
	a.Base::fun(4);//访问父类成员函数需要用作用域
}

int main()
{
	fun_A();
	//输出
	//100
	//2000
	//A : fun()
	//Base : fun()
	//n = 4
	//Base:fun(int n)
	return 0;
}  

注意，同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式（通过对象和类名）

//例如上述代码中
//Base中有静态成员函数
static void fun();//static 静态成员函数

//A中有静态成员函数
static void fun();//static 静态成员函数

//可以利用下面的两种方式访问
A::Base::fun();//访问父类成员函数需要用作用域  对象
a.Base::fun();//访问父类成员函数需要用作用域   类名

3.c++ 基础知识-类和对象-继承-多继承

#include <iostream>  
#include <string>  
using namespace std;

//继承
// 基类 父类 包含一些公共或者说可以重复利用的内容
class Base
{
public:
	Base();
	int m_A;
};

Base::Base()
{
	m_A = 2000;
}

class Base1
{
public:
	Base1();
	int m_B;
};

Base1::Base1()
{
	m_B = 22222;
}

//公共继承 public
class A:public Base,public Base1//多继承语法
{
public:
	A();
	int m_C;
};
A::A()
{
	m_C = 10000;
}
void fun()
{
	A a;
	cout<<sizeof(a)<<endl;
	cout<<a.m_A<<endl;
	cout<<a.m_B<<endl;
	cout<<a.m_C<<endl;
	//输出
	//12  3*4(int)
	//2000
	//22222
	//10000
}
int main()
{
	fun();
	return 0;
}  

4.c++ 基础知识-类和对象-继承-菱型继承

#include <iostream>  
#include <string>  
using namespace std;

//菱型继承
// 基类 父类 包含一些公共或者说可以重复利用的内容
class Base
{
public:
	Base();
	int m_number;
};

Base::Base()
{
	m_number = 2000;
}
//利用虚继承可以解决菱型继承的问题(继承指针)
//虚继承 继承前加关键字virtual
//虚基类
//class Left : virtual public Base
class Left : virtual public Base
{
};
//class Right : public Base
class Right : virtual public Base
{

};
//公共继承 public
class Test:public Left,public Right
{
};
void fun()
{
	Test t;
	t.Left::m_number = 18;
	t.Right::m_number = 28;
	//菱型继承，变量同名，需要加作用域区分 -多份数据
	//虚继承-只有一份数据
	cout<<t.Left::m_number<<endl;//28
	cout<<t.Right::m_number<<endl;//28
	cout<<t.m_number<<endl;//28

}
int main()
{
	fun();
	return 0;
}