C++核心编程类的总结封装案例

C++类的总结封装案例

1.立方体类的封装

在C++中，我们可以定义一个立方体（Cube）类来封装立方体的属性和方法。立方体的属性可能包括边长（side length），而方法可能包括计算表面积（area）和体积（volume）。

#include <iostream>
using namespace std;

class Cube {
private:
    int  sideLength; // 立方体的边长

public:

    // 计算表面积的方法
    int getArea() {
        return 6 * sideLength * sideLength; // 立方体有6个面，每个面的面积是边长的平方
    }

    // 计算体积的方法
    int getVolume(){
        return sideLength * sideLength * sideLength; // 体积是边长的三次方
    }

    // 设置边长的方法（可选）
    void setSideLength(int length) {
        sideLength = length;
    }
};

int main() {
    // 创建一个边长为5的立方体对象
    Cube cube{};
    cube.setSideLength(5);
    // 输出立方体的表面积和体积
    cout << "Area of the cube: " << cube.getArea() << endl;
    cout << "Volume of the cube: " << cube.getVolume() << endl;

    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

在上面的代码中，我们定义了一个名为Cube的类，它有一个私有成员变量sideLength来存储立方体的边长。我们还定义了两个公有成员函数getArea和getVolume来计算立方体的表面积和体积。此外，我们还提供了一个构造函数来初始化立方体的边长，以及两个可选的公有成员函数setSideLength和getSideLength来设置和获取边长。在main函数中，我们创建了一个边长为5的立方体对象，并输出了它的表面积和体积。

2.点与圆的关系的封装

在C++中，我们要封装点与圆的关系，首先需要两个类，一个点类和一个圆类。然而在实际开发中，把所有的类都放在一个文件中会导致文件的难以管理，以及可维护性的降低。这时就需要类的分文件编写。

首先要封装一个点类。我们通常在头文件中声明类，在源文件中编写成员函数。

#include "point.h"

/**
 * 设置点的X坐标
 * @param x 新的X坐标值
 */
void point::setX(double x) {
    X = x;
}

/**
 * 设置点的Y坐标
 * @param y 新的Y坐标值
 */
void point::setY(double y) {
    Y = y;
}

/**
 * 获取点的X坐标
 * @return 当前的X坐标值
 */
double point::getX(){
    return X;
}

/**
 * 获取点的Y坐标
 * @return 当前的Y坐标值
 */
double point::getY(){
    return Y;
}

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

在头文件声明类。

#pragma once
#include "point.h"

/**
 * @class point
 * 二维平面中的点类定义。
 * 该类用于表示二维平面中的一个点，包含点的X坐标和Y坐标。
 */
class point {
    double X; /**< 点的X坐标 */
    double Y; /**< 点的Y坐标 */

public:
    /**
     * 设置点的X坐标。
     * @param x 新的X坐标值。
     */
    void setX(double x);

    /**
     * 设置点的Y坐标。
     * @param y 新的Y坐标值。
     */
    void setY(double y);

    /**
     * 获取点的X坐标。
     * @return 当前点的X坐标值。
     */
    double getX();

    /**
     * 获取点的Y坐标。
     * @return 当前点的Y坐标值。
     */
    double getY();

};

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

圆类的封装。与点类分文件相同。

#include "circle.h"
#include "point.h"

/**
 * 设置圆的半径
 * @param r 圆的新半径
 */
void  circle::setRadius(double r){
    radius=r;
}

/**
 * 获取圆的半径
 * @return 圆的半径
 */
int circle::getRadius() const{
    return radius;
}

/**
 * 设置圆的中心点
 * @param p 新的中心点坐标
 */
void circle::setCenter(point p){
    center=p;
}

/**
 * 获取圆的中心点
 * @return 圆的中心点坐标
 */
point circle::getCenter() {
    return center;
}
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

圆类的头文件。

#pragma once
#include "point.h"

/**
 * @brief 表示一个圆的类
 * 
 * 该类定义了一个圆，包括圆的半径和圆心。提供了设置和获取半径以及设置和获取圆心的方法。
 */
class circle {
public:
    /**
     * @brief 设置圆的半径
     * 
     * @param r 圆的新半径
     */
    void setRadius(double r);

    /**
     * @brief 获取圆的半径
     * 
     * @return 圆的半径
     */
    [[nodiscard]] int getRadius() const;

    /**
     * @brief 设置圆的圆心
     * 
     * @param p 新的圆心坐标点
     */
    void setCenter(point p);

    /**
     * @brief 获取圆的圆心
     * 
     * @return 圆的圆心坐标点
     */
    point getCenter();

private:
    double radius; /**< 圆的半径 */
    point center;  /**< 圆的圆心 */
};
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

在主函数中对类进行调用。

#include "iostream"
using namespace std;
#include "circle.h"
#include "point.h"

/**
 * 判断一个点是否在给定圆上、内部或外部。
 * @param c 圆对象，包含圆的中心和半径。
 * @param p 点对象，要判断的点的坐标。
 */
void isSame(circle& c, point& p)
{
  // 计算圆的半径的平方
  int doRadius = c.getRadius() * c.getRadius();
  // 计算点到圆心的距离的平方
  double length;
  length = (c.getCenter().getX() - p.getX()) * (c.getCenter().getX() - p.getX())
           + ((c.getCenter().getY() - p.getY()) * (c.getCenter().getY() - p.getY()));
  // 判断点的位置：在圆上、在圆内还是在圆外
  if (doRadius == length)
    cout << "在圆上" << endl;
  else if (doRadius > length)
    cout << "在圆内" << endl;
  else
    cout << "在圆外" << endl;
}

int main() {
    circle c{};
    point p{};
    // 设置圆的半径
    c.setRadius(5);
    // 设置点的坐标
    p.setX(5);
    p.setY(0);
    // 设置圆的中心为给定的点
    c.setCenter(p);
    // 输出圆的中心坐标和半径
    cout << "圆心坐标为(" << c.getCenter().getX() << "," << c.getCenter().getY() << ")" << endl;
    cout << "半径为" << c.getRadius() << endl;
    point p1{};
    // 设置另一个点的坐标
    p1.setX(5);
    p1.setY(10);
    // 判断该点是否在圆上、内部或外部
    isSame(c, p1);
    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

主函数用于判断一个点是否在给定圆上、内部或外部。函数接受一个圆对象和一个点对象作为参数，通过计算点到圆心的距离与圆的半径的平方进行比较，来确定点的位置关系。具体步骤如下：
计算圆的半径的平方，存储在变量doRadius中。
计算点到圆心的距离的平方，存储在变量length中。
通过比较doRadius和length的大小关系，判断点的位置：
若doRadius等于length，则点在圆上。
若doRadius大于length，则点在圆内。
若doRadius小于length，则点在圆外。
根据判断结果，输出相应的信息。
在main函数中，首先创建了一个圆对象和一个点对象，并设置了圆的半径和点的坐标。然后通过调用isSame函数，判断另一个点是否在圆上、内部或外部，并输出相关信息。

3.总结

在C++中，类是面向对象编程（OOP）的核心概念之一。类是一种用户定义的数据类型，它允许我们将数据（成员变量）和操作这些数据的方法（成员函数）组合在一起。下面是对C++中类的一些关键知识总结：

1. 类的定义：
   • 使用class关键字定义类。
   • 类可以包含私有（private）、保护（protected）和公有（public）成员。
   • 私有成员只能被类内部的成员函数访问，而公有和保护成员可以在类外部被访问（对于保护成员，派生类也可以访问）。
2. 成员变量（也称为属性或字段）：
   • 成员变量是类的数据部分，用于存储类的状态。
   • 它们可以在类的声明中定义，也可以在类的实现文件（如果有的话）中定义。
3. 成员函数（也称为方法）：
   • 成员函数是类的方法部分，定义了可以对类的数据进行哪些操作。
   • 它们可以是普通的函数，也可以是构造函数、析构函数、拷贝构造函数、移动构造函数、拷贝赋值运算符和移动赋值运算符等特殊成员函数。
4. 访问修饰符：
   • public：类外部可以访问的成员。
   • private：类外部无法访问的成员，只能被类内部（包括成员函数和友元）访问。
   • protected：与private类似，但允许派生类访问。

这些是C++中类的一些关键概念和特性。通过学习和使用这些特性，我们可以编写更加灵活、可重用和易于维护的代码。