类（class）

ヾ(≧▽≦*)o

2024-08-28 10:13:00

发布于：广东

5阅读

0回复

0点赞

(1)类的概念及简单应用

类的概念

定义：
在 C++ 中，类是一个用户定义的数据类型，它封装了数据成员（变量）和成员函数（方法）。类定义了对象的属性和行为。
实例化：
类本身不是一个对象，但可以通过实例化类来创建对象。每个对象是类的一个实例。
封装：
类封装了数据和方法。数据成员通常设置为私有（private），而方法可以设置为公共（public），从而控制对数据的访问。
继承：
类可以继承其他类的特性。派生类（子类）继承基类（父类）的属性和方法，并可以扩展或重写这些属性和方法。
多态：
多态允许不同的类通过相同的接口调用不同的方法。这通常通过虚函数（virtual）实现，允许子类重写父类的方法。
抽象：
抽象类是不能被实例化的类，通常包含一个或多个纯虚函数（pure virtual），用于定义接口而不提供具体实现。

简单应用示例

下面是一个使用类的示例：

(代码源自网络，如果有误，还请指正)

#include <iostream>
#include <cmath>

using namespace std;

// 基类 Shape
class Shape {
public:
    virtual double area() const = 0; // 纯虚函数，定义接口
};

// Circle 继承自 Shape
class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}

    double area() const override {
        return M_PI * radius * radius;
    }
};

// Rectangle 继承自 Shape
class Rectangle : public Shape {
private:
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}

    double area() const override {
        return width * height;
    }
};

int main() {
    Shape* shapes[2];
    shapes[0] = new Circle(5);
    shapes[1] = new Rectangle(4, 6);

    for (int i = 0; i < 2; ++i) {
        cout << "The area of the shape is " << shapes[i]->area() << endl;
    }

    return 0;
}

解释

类定义：
Shape 类是一个抽象基类，包含一个纯虚函数 area。Circle 和 Rectangle 类继承自 Shape，并实现了 area 方法。
封装：
Circle 和 Rectangle 类将属性 radius, width, 和 height 封装在内部，并提供公共方法 area 计算面积。
多态：
使用基类 Shape 指针调用 area 方法，不同的形状（圆形和矩形）会执行各自实现的 area 方法，体现了多态。

(2)成员函数和运算符重载

1. 成员函数

成员函数是类中的一个函数，它可以访问类的成员变量和其他成员函数。成员函数可以是公有的、私有的或受保护的，取决于其访问权限的设置。

定义和使用

class MyClass {
public:
    // 成员变量
    int value;

    // 成员函数
    void setValue(int v) {
        value = v;
    }

    int getValue() const {
        return value;
    }
};

int main() {
    MyClass obj;
    int n;
    cin >> n;
    obj.setValue(n);
    int v = obj.getValue(); 
    return 0;
}

在这个例子中，setValue 和 getValue 是 MyClass 的成员函数。setValue 用于设置 value，而 getValue 用于获取 value 的值。

2. 运算符重载

运算符重载允许你为自定义的类定义如何使用内置运算符（如 +、-、***** 等）。这使得自定义对象可以像内置类型一样进行运算。

基本语法

运算符重载通过在类内定义一个特殊的成员函数或全局函数来实现。成员函数的重载运算符需要是类的成员函数，而全局函数的重载运算符则不需要是类的成员函数。

示例：重载 + 运算符，来实现复数的加法

#include <iostream>
using namespace std;
class Complex {
public:
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}

    // 成员函数重载 +
    Complex operator+(const Complex& other) const {
        return Complex(real + other.real, imag + other.imag);
    }

    void print() const {
        cout << real << " + " << imag << "i" << std::endl;
    }

private:
    double real, imag;
};

int main() {
    Complex c1(1.0, 2.0);//定义两个复数
    Complex c2(3.0, 4.0);
    Complex c3 = c1 + c2; // 使用重载的 + 运算符
    c3.print(); // 输出
    return 0;
}