类和对象-继承-同名成员和静态同名成员处理

1.同名成员处理

1.同名成员变量处理

#include<iostream>
using namespace std;
class Base
{
public:
	Base()
	{
		m_A = 100;
	}
	int m_A;
};
class Son:public Base
{
public:
	Son()
	{
		m_A = 200;
	}
	int m_A;
};
void test()
{
	Son s1;
	cout << s1.m_A << endl;   //打印结果为200
	cout << s1.Base::m_A << endl;  //打印结果为100                      
	//当子类和父类的成员变量同名时，子类可以直接访问到子类中的成员变量，若想要访问父类中
	//的同名成员变量，需要加上作用域(Base::)
}
int main()
{
	test();
	return 0;
}

运行结果

2.同名函数处理

#include<iostream>
using namespace std;
class Base
{
public:
	void func()
	{
		cout << "Base中的func()函数" << endl;
	}
void func(int a)
	{
		cout << "Base中的func(int a)函数" << endl;
	}
};
class Son:public Base
{
public:
	void func()
	{
		cout << "Son中的func()函数" << endl;
	}
};
void test1()
{
	Son s1;
	s1.func();   //打印结果为：Son中的func()函数
	s1.Base::func(); //打印结果为：Base中的func()函数
	//s1.func(2);  这里会出错,当子类和父类中有同名的成员函数时，子类会隐藏父类中说有版本（重载）的同名成员函数
	//要想访问父类中被隐藏的同名成员函数时，必须加上作用域(Base::)	
	s1.Base::func(2);  //打印结果为：Base中的func(int a)函数

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

运行结果

2.同名静态成员处理

1.同名静态成员变量处理

#include<iostream>
using namespace std;
class Base
{
public:
	static int m_A;
};
int Base::m_A = 100; 
//静态成员变量特点
//1.在类内生命，类外初始化
//2.编译阶段分配内存
//3.所有对象共享同一份数据
class Son:public Base
{
public:
	static int m_A;
};
int Son::m_A = 200;
void test()
{
	Son s1;
	//通过对象访问
	cout << s1.m_A << endl;
	cout << s1.Base::m_A << endl;
	//通过类名访问
	cout << Son::m_A << endl;
	//第一个::表示通过类名访问      第二个::表示访问父类作用域下
	cout << Son::Base::m_A << endl;
	//子类可以直接访问同名静态成员变量，入股想要访问父类中的同名静态成员变量则需要加上作用域
}
int main()
{
	test();
	return 0;
}

运行结果

2.同名静态成员函数处理

#include<iostream>
using namespace std;
class Base
{
public:
	static void func()
	{
		cout << "Base-static void func()" << endl;
	}
	static void func(int a)
	{
		cout << "Base-static void func(int a)" << endl;
	}

};
class Son:public Base
{
public:
	static void func()
	{
		cout << "Son-static void func()" << endl;
	}
	//静态函数特点：
	//1.只能访问静态成员变量，不能访问非静态成员变量
	//2.所有对象共享

};

void test1()
{
	Son s1;
	//通过对象访问
	s1.func();
	s1.Base::func();
	//通过类名访问
	Son::func();
	Son::Base::func();
	s1.func(2);//这样会出错，子类会隐藏父类中所有版本的同名静态成员函数，必须加上作用域
	s1.Base::func(2);//加上作用域之后就不会出错了
}
int main()
{
	test1();
	return 0;
}

运行结果