C++学习笔记之继承/继承的学习/继承学习/学习继承
继承是面向对象三大特性之一
//继承的语法: class 子类 : 继承方式 父类
//继承的方式一共有三种
//1 公有继承
//2 保护继承
//3 私有继承
class Base1
{
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
//公有继承
class Son1 : public Base1 {
public:
void func() {
m_A; //可访问 public权限
m_B; //可访问 protected权限
//m_C; 不可访问
}
};
void myClass()
{
Son1 s1;
s1.m_A; //其他类只能访问到公共权限
}
class Base2
{
public:
int m_A;
protected:
int m_B;
private:
int m_C
};
class Son2 : protected Base2
{
public:
void func()
{
m_A; //可访问 protected权限
m_B; //可访问 protected权限
//m_C; //不可访问
}
};
void myClass2()
{
Son2 s;
//s.m_A; //不可访问
}
//私有继承
class Base3
{
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
class Son3 : private Base3
{
public:
void func()
{
m_A; //可访问 private权限
m_B; //可访问 private权限
//m_C //不可访问
}
};
class GrandSon3 : public Son3
{
public:
void func()
{
//Son3是私有继承,所以继承Son3的属性在GrandSon3中都无法访问到
//m_A;
//m_B;
//m_C;
}
};
有些类与类之间存在特殊的关系
父类中所有非静态成员属性都会被子类继承下去
父类中私有成员属性,是被编译器隐藏了,因此是访问不到,但是确实被继承了
继承中构造函数和析构函数的顺序
子类继承父类后,当创建子类对象,也会调用父类的构造函数
先构造父类,在构造子类,析构的顺序与构造的顺序相反
#include <iostream>
using namespace std;
class Base
{
public:
Base()
{
cout << "Base构造函数!" << endl;
}
~Base()
{
cout << "Base析构函数!" << endl;
}
};
class Son : public Base
{
public:
Son()
{
cout << "Son构造函数!" << endl;
}
~Son()
{
cout << "Son析构函数!" << endl;
}
};
void test()
{
//继承中 先调用父类的构造函数,在调用子类构造函数, 析构顺序与构造函数相反
Son s;
}
int main()
{
test();
return 0;
}
//总结: 继承中 先调用父类构造函数,再调用子类构造函数,析构顺序与构造相反
继承同名成员处理方式
访问子类同名函数,直接访问即可。
访问父类同名成员,需要加作用域。
如果子类中出现和父类同名的成员函数,子类的同名成员会隐藏掉父类中所有同名成员函数
子类对象可以直接访问子类中同名成员
子类对象加作用域可以访问到父类同名成员
当子类和父类拥有同名的成员函数,子类会隐藏父类中同名成员函数,加个作用域可以访问到父类同名函数
#include <iostream>
using namespace std;
class Base
{
public:
Base()
{
m_A = 100;
}
void func()
{
cout << "Base - func()调用" << endl;
}
void func(int a)
{
cout << "Base-func(int a)调用" << endl;
}
public:
int m_A;
};
class Son : public Base
{
public:
Son()
{
m_A = 200;
}
//当子类父类拥有同名的成员函数,子类会隐藏父类中所有版本的同名成员函数
//如果想访问父类中被隐藏的同名成员函数,需要加父类的作用域
void func()
{
cout << "Son - func()调用" << endl;
}
public:
int m_A;
};
void test01()
{
Son s;
cout << "Son下的m_A = " << s.m_A << endl;
cout << "Base下的m_A = " << s.Base::m_A << endl;
s.func();
s.Base::func();
s.Base::func(10);
}
int main()
{
test01();
return 0;
}
//子类对象可以直接访问到子类中同名成员
//子类对象加作用域可以访问到父类同名成员
//当子类与父类拥有同名的成员函数,子类会隐藏父类中同名的成员函数,加作用域可以访问到父类中同名函数
多继承语法
多继承可能会引发父类有同名成员出现需要加作用域区分
#include <iostream>
using namespace std;
class Base1
{
public:
Base1()
{
m_A = 100;
}
public:
int m_A;
};
class Base2
{
public:
Base2()
{
m_A = 200; //开始是m_B 不会出问题,但是改为mA就会出现不明确
}
public:
int m_A;
};
//语法 class 子类 : 继承方式 父类1 , 继承方式 父类2
class Son : public Base1, public Base2
{
public:
Son()
{
m_C = 300;
m_D = 400;
}
public:
int m_C;
int m_D;
};
//多继承容易产生成员同名的情况
//通过使用类名作用域可以区分调用哪一个基类的成员
void test()
{
Son s;
cout << "sizeof Son " << sizeof(s) << endl;
//cout << "s.m_A" << s.m_A << endl;
cout << "s.Base1::m_A " << s.Base1::m_A << endl;
cout << "s.Base2::m_A " << s.Base2::m_A << endl;
}
int main()
{
test();
return 0;
}
//总结:多继承如果父类中出现了同名情况,子类使用时要加作用域
菱形继承
菱形继承概念:
两个派生类继承同一个基类。
又有某个类同时继承两个派生类
这种继承被称为菱形继承,或者钻石继承
当菱形继承,两个父类拥有相同数据,需要加作用域区分
利用虚继承,解决菱形继承的问题
继承之前,加上关键字virtual变为虚继承
#include <iostream>
using namespace std;
class Animal
{
public:
int m_Age;
};
//继承前virtual 关键字了,变为虚继承
//此时公共的父类Animal称为虚基类
class Sheep : virtual public Animal {};
class Tuo : virtual public Animal {};
//class Sheep : public Animal {};
//class Tuo : public Animal {};
class SheepTuo : public Sheep, public Tuo{};
void test()
{
SheepTuo st;
//使用对象进行访问 对象名+作用域+成员属性访问
st.Sheep::m_Age = 100;
st.Tuo::m_Age = 200;
cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
cout << "st.Tuo::m_Age = " << st.Tuo::m_Age << endl;
cout << "st.m_Age = " << st.m_Age << endl;
}
int main()
{
test();
return 0;
}
//菱形继承带来的主要问题是子类继承两份相同的数据, 导致资源浪费以及毫无意义
//利用虚继承可以解决菱形继承的问题
C++学习笔记之继承/继承的学习/继承学习/学习继承