浅谈C++

class 类名
{
​		public:
​				<共有数据和函数>
​		protected:
​				<保护数据和函数>
​		private:
​				<私有数据和函数>

};
1
2
3
4
5
6
7
8
9
10

<类名> <对象名表>;
1

Point p1,p2,*pdate,p[3],&rp=p1;
1

<类名>::<类名>(形参表)
{
	<函数体>
}
1
2
3
4

<类名>::<类名>(){}
1

<类名>::~<类名>(){}
1

<类名>::~<类名>(){}
1

<类名>::<类名>(const <类名>&<对象名>)
{
	<函数体>
}
1
2
3
4

<数据类型><类名>::<静态数据成员名>=<初始值>;
1

friend <类型><友元函数名>(<参数表>);
1

#include
using namespace std;
class Point {
public:
	//构造函数
	Point(double x, double y);
	//析构函数
	~Point();
	//计算距离的友元函数
	friend double distance(Point& a, Point& b);
private: //私有成员变量
	double X, Y;
};

//构造函数的实现
Point::Point(double x, double y) {
	X = x;
	Y = y;
}

//析构函数的实现
Point::~Point() {
	cout << "析构函数被调用~";
}

//在类的外部对友元函数进行实现
double distance(Point &a, Point &b) { //两个参数都是对Point类的对象的引用
	double len;
	len = sqrt(pow((a.X - b.X), 2) + pow((a.Y - b.Y), 2));
	cout << "两点之间的距离为:" << len << endl;
	return len;
}

int main() {

	//创建两个点对象
	Point A(0, 0), B(3, 4);
	distance(A, B); //调用友元函数,计算两个点之间的距离

	return 0;

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

friend class<类名>;
1

#include
using namespace std;

//基类1
class Base1{ 
public:
void show(){
     cout<<"这是基类1的show函数"<

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30

程序运行结果如下:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ADbJIPil-1661676070859)(C:\Users\LLL\Desktop\python\2.笔记\image-20210626173804836.png)]

由于同时继承的两个基类中都有show方法,因此派生类的子对象关于要调用哪个show方法的时候指向不明确,程序报错.

解决办法:

可以使用作用域运算符,指明要调用的show方法来自继承的哪一个类,例(调用Base1的show方法):

demo.Base1::show();
1

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mMvwPgsx-1661676070860)(C:\Users\LLL\Desktop\python\2.笔记\image-20210626174142657.png)]

4.1.3支配原则

类X中的名字N支配类Y中同名的名字N,是指类X以类Y为它的一个基类,这称为支配原则.如果一个名字支配另一个名字,则二者之间不存在二义性,当选择该名字时,使用支配者的名字即可.

例(利用支配原则解决上述的二义性问题):

如果在派生类中定义一个自己的show方法,那么就出现了与基类中同名的情况,那么派生类的对象在调用show方法试,会使用支配者的show方法(即派生类自己的show方法):

class Child : public Base1, public Base2 {
public:
    void show() {
        cout << "这是派生类的show方法" << endl;
    }
};
1
2
3
4
5
6

程序同样正常运行:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P3uR1TBQ-1661676070860)(C:\Users\LLL\Desktop\python\2.笔记\image-20210626174936787.png)]

4.1.4虚基类

引进虚基类的目的是为了解决二义性问题,使得公共基类在它的派生类对象中只产生一个基类子对象.虚基类说明的格式如下:

virtual <继承方式> <基类名>
1

其中,virtual是说明虚基类的关键字.虚基类的说明是用在定义派生类时,写在派生类名的后面.

4.1.5多继承机制下构造函数的调用顺序

1. 首先基类构造函数被调用
2. 子对象所在类的构造函数次之
3. 最后执行派生类构造函数

多继承机制下析构函数的调用顺序与之相反

4.2程序设计

定义一个点类(Point).矩形类(Rectangle)和立方体类(Cube)的层次结构.矩形包括长度和宽度两个新数据成员,矩形的位置从点类继承.立方体类由长度,宽度和高度构成.要求各类提供支持初始化的构造函数和显示自己成员的成员函数.编写主函数,测试这个层次结构,输出立方体类的相关信息.

#include
using namespace std;
//定义一个点类
class Point {
public:
    static int ObjNum; //定义一个静态成员变量 用于记录创建的对象的个数
    Point(double x, double y); //构造函数
    ~Point(); //析构函数
    void show(); //用于显示成员数据的函数
private:
    double X, Y;//点的坐标x和y的值
};

//点类的成员函数的实现
Point::Point(double x, double y) {
    cout << "点类的构造函数被调用" << endl;
    X = x;
    Y = y;
    ObjNum ++; //如果构造函数调用成功,说明对象创建成功,对象数量加1
    cout << "当前的对象数量为:" << Point::ObjNum << endl;

}
//点类的析构函数
Point::~Point() {
    cout << "点类的析构函数被调用" << endl;
    ObjNum--; //如果析构函数调用成功,说明对象销毁成功,对象数量减1
    cout << "当前的对象数量为:" << Point::ObjNum << endl;

}

void Point::show() {
    cout << "我的坐标位置是:(" << X << "," << Y << ")" << endl;
}

//定义一个矩形类 继承自点类
class Rectangle :public Point
{
public:
    //构造函数
    Rectangle(double x, double y, double length, double width);
    //析构函数
    ~Rectangle() {
        cout << "矩形类的析构函数被调用" << endl;
        cout << "当前的对象数量为:" << Point::ObjNum << endl;

    }
    //矩形类的show函数
    void show();
    double area;//(表)面积
private:
    double Length, Width;//矩形的长度 宽度 


};
//矩形类构造函数的实现
Rectangle::Rectangle(double x, double y, double length, double width) :Point(x,y) { //Point(x,y):点类的数据成员的初始化,同时也会调用点类的构造函数
    cout << "矩形类的构造函数被调用" << endl;
    Length = length;
    Width = width;
    area = length * width;
    cout << "当前的对象数量为:" << Point::ObjNum << endl;

}

//矩形类show方法的实现
void Rectangle::show() {
    Point::show();
    cout << "我的长度和宽度分别是:" << Length << "," << Width << endl;
    cout << "我的(表)面积是:" << area << endl;
}

//定义一个立方体类 继承自矩形类
class Cube :public Rectangle {
public:
    //立方体类的构造函数
    Cube(double x, double y, double length, double width, double height);
    //立方体类的析构函数
    ~Cube() {
        cout << "立方体类的析构函数被调用" << endl;
    }

    //立方体类的show函数
    void show();
private:
    double Height, V;
};

//立方体类构造函数的实现
Cube::Cube(double x, double y, double length, double width, double height) :Rectangle( x,  y, length, width) {
    cout << "立方体类的构造函数被调用" << endl;
    Height = height;
    //因为在Rectangle中,area是共有成员变量,所以通过public的方式下来能够有权限访问到
    area = (length * width + length * height + width + height) * 2; //重写表面积的计算方法
    V = length * width * height; //体积
    cout << "当前的对象数量为:" << Point::ObjNum << endl;
}

//立方体类的show函数
void Cube::show() {
    Rectangle::show(); //调用矩形类的show方法
    cout << "我的高度是" << Height << endl;
    cout << "我的体积是" << V << endl;
}
//初始化静态数据成员 (不能在main函数里面初始化)
int Point::ObjNum = 0;
int main() {

    //初始化以立方体类
    double x = 0, y = 0, length = 10, width = 10, height = 10;
    Cube demoCube(x, y, length, width, height);
    demoCube.show();
    //初始化一个点类
    Point demoPoint(x,y);
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

多态性和虚函数

5.1静态联编和动态联编

多态性就是统一符号或者名字在不同情况下具有不同解释现象,即是指同一个函数的多种形态.c++可以支持两种多态性,编译时的多态性和运行时的多态性.

5.1.1静态联编(速度快)

静态联编是指在程序编译连接阶段进行的联编.编译器根据源代码调用固定的函数标识符,然后由连接器管这些标识符,并用物理地址代替它们.这种联编又被称为早起联编,因为这种联编工作是在程序运行之前完成的.静态联编所支持的多态性称为编译时的多态性.

5.1.2动态联编

动态联编是指在程序运行时进行编译.只有向具有多态性的函数传递一个实际对象时,该函数才能与多种可能的函数中的一种联系起来.这种联编有称为晚期联编.动态联编所支持的多态性被称为运行时的多态性.

5.1.3虚函数

虚函数是一个成员函数,该成员函数在基类内部声明并且被派生类重新定义,为了创建虚函数,应在基类中该函数声明前加上关键字virtual.虚函数的定义格式如下:

virtual <返回值类型><函数名>(<形式参数表>)
{
<函数体>
}
1
2
3
4

其中,virtual是关键字,被该关键字说明的函数为虚函数.

虚函数与一般重载函数的区别,主要有一下几点:

• 重载函数只要求有相同的函数名,而且重载函数是在相同作用域中定义的名字相同的不同函数.而虚函数不仅要求函数名相同,而且要求函数的签名,返回类型也相同.也就是说函数原型必须完全相同,而且虚函数特性必须是体现在基类和派生类的类层次结构中.
• 重载函数可以是成员函数或友元函数,而虚函数子类是非静态成员函数.
• 构造函数可以重载,析构函数不能重载.正好相反,构造函数不能定义为虚函数,析构函数能定义为虚函数.
• 重载函数的调用是以所传递参数序列的差别作为调用不同函数的依据,而虚函数是根据对象的不同去调用不同类的虚函数.
• 重载函数在编译时表现出多态性,是静态联编;而虚函数则在运行时表现出多态性,是动态联编,因此说明动态联编是c++的精髓.

5.1.3.1纯虚函数

如果不能在基类中给出有意义的纯虚函数的实现,但又必须让基类为派生类提供一个公共界面函数.这时可以将它说明为纯虚函数,它的实现留给派生类来做.说明纯序函数的一般形式为:

virtual <返回值类型><函数名>(<形式参数表>)=0;
1

5.1.3.2抽象类

一个类可以说明多个纯虚函数,对于包含有纯虚函数的类被称为抽象类.一个抽象类只能作为基类来派生新类,不能说明抽象类的对象.因为抽象类中有一个或者多个函数没有定义.

6.程序设计

(1)使用虚函数编写程序求球体和圆柱体的体积及表面积.由于球体和圆柱体都可以看作由圆继承而来,所以可以定义圆类Circle作为基类.在Circle类中定义一个数据成员radius和两个虚函数area()和volume().由Circle类派生Sphere类和Column类.在派生类中对虚函数area()和volumn()重新定义,分别求球体和圆柱体的体积及表面积.

#include
using namespace std;

//定义基类Circle
class Circle {

public:
    //声明圆类的构造函数
    Circle(double r);

    //声明求面积的area虚函数
    virtual double area();

    //声明求体积的volumn纯虚函数
    virtual double volumn() = 0;
//private:
    double radius;//半径

};

//圆类构造函数的实现 初始化半径
Circle::Circle(double r) {
    radius = r;
}

//圆类面积函数的实现
double Circle::area() {
    return 3.14 * radius * radius;
}

//定义球类 继承自Circle类
class Sphere :public Circle {

public:
    //声明球类的构造函数
    Sphere(double r);

    //声明球类的计算表面积的函数area
    double area();

    //声明球类的计算体积的函数volumn
    double volumn();


//private:
    double V; //体积
};

//球类构造函数的实现
Sphere::Sphere(double r) :Circle(r) {
    V = 4 * 3.14 * pow(radius, 3) / 3;
}

//球类area函数的实现
double Sphere::area() {

    return 4 * 3.14 * pow(radius,2);

}

//球类volumn函数的实现
double Sphere::volumn() {
    return 4 * 3.14 * pow(radius, 3) / 3;
}

//定义圆柱类 继承自圆类
class Column :public Circle {

public:
    //圆柱类的构造函数
    Column(double r, double h);

    //圆柱类的area函数
    double area();

    //圆柱类的volumn函数
    double volumn();

private:
    double height; //圆柱体的高

};


//圆柱类构造函数的实现
Column::Column(double r, double h) :Circle(r) {
    height = h;
}

//圆柱体的area函数的实现
double Column::area() {
    return 3.14 * pow(radius, 2) * 2 + 2 * 3.14 * radius * height;
}

//圆柱体volumn函数的实现
double Column::volumn() {
    return 3.14 * pow(radius, 2) * height;
}

int main() {


    //实例一个球体
    double r = 12;
    double h = 10;
    double area, volumn;
    Sphere demoSphere(r);
    area = demoSphere.area();
    volumn = demoSphere.volumn();
    cout << "半径为" << r << "的球的体积为:" << volumn << "表面积为:" << area << endl;

    //实例一个圆柱体
    Column demoColumn(r, h);
    volumn = demoColumn.volumn();
    area = demoColumn.area();
    cout << "半径为" << r <<"高度为:"<