继承的好处:减少重复的代码;
形式:class A:继承方式 B{};
A类称为子类或派生类;
B类称为父类或基类;
因此子类的成员包括两类:
一类是从父类继承过来的,一类是自己增加的成员;从基类继承过来的表达其共性,而新增的成员体现了其个性;
继承方式:
注:从父类中继承的私有属性,无论是在子类内还是子类外都无法通过子类进行访问。
子类继承父类后的空间变化:
1.父类中所有非静态成员属性都会被子类继承下去;
2.父类中私有成员属性是被编译器隐藏了,因此访问不到,但确实被继承下去了。
class A
{
public:
int a;
protected:
int b;
private:
int c;
};
class B :public A
{
public:
int d;
};
void test01()
{
cout << sizeof(B) << endl;//输出16;
}
int main()
{
test01();
return 0;
}
继承中构造和析构的顺序:
子类继承父类后,当创建子类对象,也会调用父类的构造函数;
口诀:先有父后有子,白发送黑发;
意思是:构造函数先执行父类的再执行子类,析构函数子类的先执行父类后执行;
继承同名成员处理方式:
非静态同名
1.访问子类同名成员,直接访问即可;
2.访问父类同名成员,需要加作用域;
即:如果子类出现和父类同名的成员函数,子类的同名成员会隐藏掉父类中所有同名成员函数(包括重载函数),如果想要访问到父类中被隐藏的同名成员函数,需要加作用域;
class Base
{
public:
void func(int a)
{
cout << "Base中void func(int a)的调用" << endl;
}
void func()
{
cout << "Base中void func()的调用" << endl;
}
int m_A=100;
};
class Son :public Base
{
public:
void func()
{
cout << "Son中void func()的调用" << endl;
}
int m_A=200;
};
void test01()
{
//非静态成员引用必须与特定对象相对,因此要先创建对象。
Son s1;
cout << s1.m_A << endl;//200
cout << s1.Base::m_A << endl;//100
s1.func();//Son中void func()的调用
s1.Base::func(100);//Base中void func(int a)的调用
s1.Base::func();//Base中void func()的调用
}
int main()
{
test01();
return 0;
}
静态同名
有两种访问方法:
1.通过对象访问
2.通过类名访问
class Base
{
public:
void static func(int a)
{
cout << "Base中void static func(int a)的调用" << endl;
}
void static func()
{
cout << "Base中void static func()的调用" << endl;
}
int static m_A;
};
int Base::m_A = 100;
class Son :public Base
{
public:
void static func()
{
cout << "Son中void static func()的调用" << endl;
}
int static m_A;
};
int Son::m_A = 200;
void test01()
{
//通过对象访问;
Son s1;
cout << s1.m_A << endl;
cout << s1.Base::m_A << endl;
s1.func();
s1.Base::func(100);
s1.Base::func();
//输出:
//200
//100
//Son中void static func()的调用
//Base中void static func(int a)的调用
//Base中void static func()的调用
//通过类名访问
cout << Son::m_A << endl;
cout << Son::Base::m_A << endl;
Son::func();
Son::Base::func(100);
Son::Base::func();
//输出:
//200
//100
//Son中void static func()的调用
//Base中void static func(int a)的调用
//Base中void static func()的调用
}
int main()
{
test01();
return 0;
}
多继承:
c++允许一个类继承多个类。
语法:class 子类:继承方式 父类1,继承方式 父类2…
多继承可能会引发父类中有同名成员出现,需要加作用域区分。并不建议使用多继承。
菱形继承:
两个子类继承同一个父类,又有某个类同时继承两个子类,这种继承称为菱形继承或钻石继承。
下面展示例子:
class Person
{
public:
int m_Age;
};
class Man :public Person
{
};
class Woman :public Person
{
};
class Son :public Man, public Woman
{
};
void test01()
{
Son s1;
s1.Man::m_Age = 10;
s1.Woman::m_Age = 20;
cout << s1.Man::m_Age << endl;//10
cout << s1.Woman::m_Age << endl;//20
}
发现s1有两个m_Age,且数值不相同。菱形继承导致数据有重份,资源浪费。
如何解决菱形继承同名成员问题?
继承前加上关键字virtual,变成虚继承。
class Person//此时Person 称为虚基类
{
public:
int m_Age;
};
class Man :public virtual Person
{
};
class Woman :public virtual Person
{
};
class Son :public Man, public Woman
{
};
void test01()
{
Son s1;
s1.Man::m_Age = 10;
s1.Woman::m_Age = 20;
cout << s1.Man::m_Age << endl;
cout << s1.Woman::m_Age << endl;
cout<<s1.m_Age<<endl;//三个输出结果均为20
}
虚继承Son从两个父类中继承两个虚基类指针,指向对应的虚基类表再通过虚基类表记录的偏移量,指向m_Age.同一个Son对象中m_Age只有一份。
上面所说的资源浪费是针对Person类中有大量数据而言的。