C++旅程第七站-----类的继承
本帖最后由 这是她 于 2020-5-15 22:22 编辑Wanting to be someone else is a waste of the person you are. --Kurt Cobain
类的继承
继承的好处：减少重复代码
语法：class 子类 ： 继承方式父类
子类 -> 派生类 父类 -> 基类
派生类中的成员：
1、从基类继承过来;(共性) 2、自己增加的成员;(特性)
继承方式：公共继承私有继承保护继承
#include<iostream>
using namespace std;
class Base1
{
public:
int m_A;
void Headline1()
{
cout << "文件的标题！！！！" << endl;
}
void Time1()
{
cout << "文件创建的时间！！！！" << endl;;
}
void Author1()
{
cout << "文件的作者！！！！" << endl;
}
private:
int m_B;
protected:
int m_C;
};
//继承的方式有三种：公共继承 保护继承 私有继承
//class 子类 : 继承方式 父类
//公共继承 public
class File1 : public Base1
{
public:
void Content1()
{
cout << "文件的内容！！！！！！" << endl;
}
};
//公共继承public
class File2 : public Base1
{
public:
void test1()
{
int m_A = 10;//父类中的公共权限成员----子类->公共权限
int m_B = 10;//父类中的私有权限成员----子类->访问不到
int m_C = 10;//父类中的保护权限成员----子类->保护权限
}
}
//私有继承 private
class File3 : private Base1
{
public:
void test2()
{
int m_A = 11;//父类中的公共权限成员----子类->私有权限
int m_B = 11;//父类中的私有权限成员----子类->访问不到
int m_C = 11;//父类中的保护权限成员----子类->私有权限
}
}
//保护继承 protected
class File4 : protected Base1
{
public:
void test3()
{
int m_A = 12;//父类中的公共权限成员----子类->保护权限
int m_B = 12;//父类中的私有权限成员----子类->访问不到
int m_C = 12;//父类中的保护权限成员---- 子类->保护权限
}
}
int main()
{
File1 f1;
f1.Content1();
f1.Headline1();
f1.Time1();
f1.Author1();
File2 f2;
f2.m_A = 100;//公共权限---可以访问到
f2.m_C = 100;//保护权限---类外访问不到
File3 f3;
f3.m_A = 110;//私有权限---访问不到
File4 f4;
f4.m_A = 120;//保护权限---类外访问不到
return 0;
} 继承中的对象模型
#include<iostream>
using namespace std;
class Base2
{
public:
int m_A;
Base2()
{
cout << "Base2 的构造函数！！！！" << endl;
}
~Base2()
{
cout << "Base2 的析构函数！！！！" << endl;
}
private:
int m_B;
protected:
int m_C;
};
class Box : public Base2
{
public:
int m_D;
Box()
{
cout << "Box 的构造函数！！！！" << endl;
}
~Box()
{
cout << "Box 的析构函数！！！！" << endl;
}
};
int main()
{
//16
//父类中所有非静态成员属性都会被子类继承下去
//父类中私有成员属性--是被编译器给隐藏了，因此访问不到，但确实被继承下去了
cout << "size of Box : " << sizeof(Box) << endl;
//继承中的构造和析构顺序如下：
//先构造父类，在构造子类，析构的顺序与构造的顺序相反
Base2 b1;
Box b2;
return 0;
} 同名成员
访问子类同名成员-----直接访问 访问父类同名成员-----需要加作用域
静态同名成员访问方式： 通过对象 通过类名
#include<iostream>
using namespace std;
class Base3
{
public:
int m_A;
static int m_B;
Base3()
{
m_A = 10;
}
void magic()
{
cout << "Base3 中的magic()!!!!" << endl;
}
void magic(int a)
{
cout << "Base3 中的magic(int a)!!!!" << endl;
}
static void cute()
{
cout << "Base3 中的静态cute()!!!!" << endl;
}
};
int Base3::m_B = 20;
class Contemptible : public Base3
{
public:
int m_A;
static int m_B;
Contemptible()
{
m_A = 100;
}
void magic()
{
cout << "Contemptible 中的magic()!!!!" << endl;
}
static void cute()
{
cout << "Contemptible 中的静态cute()!!!!" << endl;
}
};
int Contemptible::m_B = 200;
//同名成员属性
void test1()
{
//如果成员属性有重名
Contemptible p1;
cout <<"子类中的成员属性 : " << p1.m_A << endl;//直接调用
cout <<"父类中的成员属性 ： " <<p1.Base3::m_A << endl;
//如果通过子类对象访问到父类中同名成员，需要加作用域：：
}
//同名成员函数
void test2()
{
//如果成员函数有重名
Contemptible p2;
p2.magic();//直接调用，调用的是子类中的同名成员
p2.Base3::magic();// 如果通过子类对象访问到父类中同名函数，需要加作用域：：
//如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数
//如果想访问到父类中被隐藏的同名成员函数，需要加作用域：：
p2.Base3::magic(1);
}
void test3()
{
//1、通过对象访问
cout << "通过对象来访问！！！" << endl;
Contemptible p3;
cout <<"子类中的静态成员属性 : " << p3.m_B << endl;
cout <<"父类中的静态成员属性 ： " <<p3.Base3::m_B << endl;
//2、通过类名来访问
cout << "通过类名来访问！！！！" << endl;
cout <<"子类中的成员属性 : " << Contemptible::m_B << endl;
//第一个：：代表通过类名的方式访问第二个：：代表访问父类作用域下
cout <<"父类中的成员属性 ： " <<Contemptible::Base3::m_B << endl;
}
void test4()
{
//如果子类中出现和父类同名的静态成员函数，子类的静态同名成员会隐藏掉父类中所有静态同名成员函数
//如果想访问到父类中被隐藏的静态同名成员函数，需要加作用域：：
//通过对象访问
Contemptible p4;
p4.cute();
p4.Base3::cute();
//通过类名访问
Contemptible::cute();
Contemptible::Base3::cute();
}
int main()
{
test1();
test2();
test3();
test4();
return 0;
} 多继承
#include<iostream>
using namespace std;
class Library1
{
public:
int m_A;
Library1()
{
m_A = 10;
}
};
class Library2
{
public:
int m_B;
int m_A;
Library2()
{
m_B = 20;
m_A = 101;
}
};
//子类----需要继承Library1和Library2
//class 子类 : 继承方式 父类1，继承方式 父类2.......
class Book : public Library1, public Library2
{
public:
int m_C;
int m_D;
Book()
{
m_C = 30;
m_D = 40;
}
};
void test1()
{
Book p1;
cout << "size of p1 : " << sizeof(p1) << endl;
//当父类中出现同名成员，需要加作用域区分
cout << "Library1::m_A : " << p1.Library1::m_A << endl;
cout << "Library2::m_A : " << p1.Library2::m_A << endl;
}
int main()
{
test1();
return 0;
}
{:10_332:} 渣渣一个望各位大佬指点指点{:10_254:}
页:
[1]