C++——类

琢瑜

于 2024-06-29 15:28:49 发布

阅读量357

点赞数 5

文章标签： c++

本文链接：https://blog.csdn.net/ITQWQ/article/details/140064994

版权

C++——类

类的初探

C++ 中的类（class）是一种编程结构，用于创建对象。这些对象可以拥有属性（即数据成员）和行为（即成员函数或方法）。类的概念是面向对象编程的核心之一，其主要目的是将数据和与数据相关的操作封装在一起。例如，如果你有一个“汽车”类，它可能包含颜色、品牌、型号等属性（数据成员），以及启动、停止、加速等行为（成员函数）。每当你基于这个类创建一个对象时，你就有了一个具体的汽车，具有这些属性和行为。

C++ 类的基本结构通常包含：

数据成员（Attributes）：定义类的属性。这些是类内部的变量，用于存储对象的状态。
成员函数（Methods）：定义类的行为。这些是可以操作对象的数据成员的函数。
构造函数和析构函数：特殊的成员函数。构造函数在创建对象时自动调用，用于初始化对象。析构函数在对象销毁时调用，用于执行清理操作。
访问修饰符：如 public, private, protected，用于控制对类成员的访问权限。例如，public 成员可以在类的外部访问，而 private 成员只能在类内部访问。
继承：允许一个类继承另一个类的特性。这是代码重用和多态性的关键。

通过这些特性，C++ 类提供了一种强大的方式来组织和处理数据，使得代码更加模块化、易于理解和维护。

结构体引入类

回忆结构体

用 C 语言实现上面描述的汽车类，我们可以实现如下代码：

#include <stdio.h>
#include <stdlib.h>

struct Car { //汽车“类”
    char *color; //颜色
    char *brand; //品牌
    char *type; //车型
    int year; //年限
    void (*printCarInfo)(char *color, char *brand, char *type, int year); //函数指针，指向车介绍函数
    void (*carRun)(char *type); //函数指针，指向车运行的函数
    void (*carStop)(char *type); //函数指针，执行车停止的函数
};

void bwmThreePrintCarInfo(char *color, char *brand, char *type, int year) {
    printf("车的品牌是：%s, 型号是: %s, 颜色是：%s, 上市年限是%d\n", brand, type, color, year);
}

void A6PrintCarInfo(char *color, char *brand, char *type, int year) {
    printf("车的品牌是：%s, 型号是: %s, 颜色是：%s, 上市年限是%d\n", brand, type, color, year);
}

int main() {
    struct Car BWMthree;
    BWMthree.color = "白色";
    BWMthree.brand = "宝马";
    BWMthree.type = "3系";
    BWMthree.year = 2023;
    BWMthree.printCarInfo = bwmThreePrintCarInfo;
    BWMthree.printCarInfo(BWMthree.color, BWMthree.brand, BWMthree.type, BWMthree.year);

    struct Car *AodiA6;
    AodiA6 = (struct Car*)malloc(sizeof(struct Car));
    AodiA6->color = "黑色";
    AodiA6->brand = "奥迪";
    AodiA6->type = "A6";
    AodiA6->year = 2008;
    AodiA6->printCarInfo = A6PrintCarInfo;
    AodiA6->printCarInfo(AodiA6->color, AodiA6->brand, AodiA6->type, AodiA6->year);
    return 0;
}

新建C++工程使用结构体

在 C++ 中，字符串用 std::string 来表示。将所有 char * 修改为 std::string 类型。

#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <iostream>
using namespace std;

class Car { //汽车“类”
public:
    string color; //颜色
    string brand; //品牌
    string type; //车型
    int year; //年限
    void (*printCarInfo)(string color, string brand, string type, int year); //函数指针，指向车介绍函数
    void (*carRun)(string type); //函数指针，指向车运行的函数
    void (*carStop)(string type); //函数指针，执行车停止的函数
};

void bwmThreePrintCarInfo(string color, string brand, string type, int year) {
    string str = "车的品牌是：" + brand + ",型号是: " + type + ",颜色是：" + color + ",上市年限是:" + std::to_string(year);
    cout << str << endl;
}

void A6PrintCarInfo(string color, string brand, string type, int year) {
    string str = "车的品牌是：" + brand + ",型号是: " + type + ",颜色是：" + color + ",上市年限是:" + std::to_string(year);
    cout << str << endl;
}

int main() {
    Car BWMthree;
    BWMthree.color = "白色";
    BWMthree.brand = "宝马";
    BWMthree.type = "3系";
    BWMthree.year = 2023;
    BWMthree.printCarInfo = bwmThreePrintCarInfo;
    BWMthree.printCarInfo(BWMthree.color, BWMthree.brand, BWMthree.type, BWMthree.year);

    Car *AodiA6 = new Car();
    AodiA6->color = "黑色";
    AodiA6->brand = "奥迪";
    AodiA6->type = "A6";
    AodiA6->year = 2008;
    AodiA6->printCarInfo = A6PrintCarInfo;
    AodiA6->printCarInfo(AodiA6->color, AodiA6->brand, AodiA6->type, AodiA6->year);
    return 0;
}

真正的成员函数

#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <iostream>
using namespace std;

class Car { //汽车“类”
public:
    //成员数据
    string color; //颜色
    string brand; //品牌
    string type; //车型
    int year; //年限
    //其实也是成员数据，指针变量，指向函数的变量，并非真正的成员函数
    void (*printCarInfo)(string color, string brand, string type, int year); //函数指针，指向车介绍函数
    void (*carRun)(string type); //函数指针，指向车运行的函数
    void (*carStop)(string type); //函数指针，执行车停止的函数
    void realPrintCarInfo(); //声明成员函数
};

void Car::realPrintCarInfo() //在类的外部进行成员函数的实现
{
    string str = "车的品牌是：" + brand + ",型号是: " + type + ",颜色是：" + color + ",上市年限是:" + std::to_string(year);
    cout << str << endl;
}

void bwmThreePrintCarInfo(string color, string brand, string type, int year) {
    string str = "车的品牌是：" + brand + ",型号是: " + type + ",颜色是：" + color + ",上市年限是:" + std::to_string(year);
    cout << str << endl;
}

void A6PrintCarInfo(string color, string brand, string type, int year) {
    string str = "车的品牌是：" + brand + ",型号是: " + type + ",颜色是：" + color + ",上市年限是:" + std::to_string(year);
    cout << str << endl;
}

int main() {
    Car BWMthree;
    BWMthree.color = "白色";
    BWMthree.brand = "宝马";
    BWMthree.type = "3系";
    BWMthree.year = 2023;
    BWMthree.printCarInfo = bwmThreePrintCarInfo;
    BWMthree.printCarInfo(BWMthree.color, BWMthree.brand, BWMthree.type, BWMthree.year);
    BWMthree.realPrintCarInfo();

    Car *AodiA6 = new Car();
    AodiA6->color = "黑色";
    AodiA6->brand = "奥迪";
    AodiA6->type = "A6";
    AodiA6->year = 2008;
    AodiA6->printCarInfo = A6PrintCarInfo;
    AodiA6->printCarInfo(AodiA6->color, AodiA6->brand, AodiA6->type, AodiA6->year);
    AodiA6->realPrintCarInfo();
    return 0;
}

组合

在 C++ 中，一个类包含另一个类的对象称为组合（Composition）。这是一种常见的设计模式，用于表示一个类是由另一个类的对象组成的。这种关系通常表示一种"拥有"（"has-a"）的关系。

普通变量访问成员变量或者成员函数，使用 . 运算符。

指针变量访问成员变量或者成员函数，使用 -> 运算符，像 C 语言的结构体用法。

#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <iostream>
using namespace std;

class Wheel {
public:
    string brand;
    int year;
    void wheelPrintInfo();
};

void Wheel::wheelPrintInfo() {
    cout << "我的轮胎品牌是：" << brand << endl;
    cout << "我的轮胎日期是：" << year << endl;
}

class Car { //汽车“类”
public:
    //成员数据
    string color; //颜色
    string brand; //品牌
    string type; //车型
    int year; //年限
    Wheel wl;
    Wheel *pwl;
    //其实也是成员数据，指针变量，指向函数的变量，并非真正的成员函数
    void (*printCarInfo)(string color, string brand, string type, int year); //函数指针，指向车介绍函数
    void (*carRun)(string type); //函数指针，指向车运行的函数
    void (*carStop)(string type); //函数指针，执行车停止的函数
    void realPrintCarInfo(); //声明成员函数
};

void Car::realPrintCarInfo() { //在类的外部进行成员函数的实现
    string str = "车的品牌是：" + brand + ",型号是: " + type + ",颜色是：" + color + ",上市年限是:" + std::to_string(year);
    cout << str << endl;
}

void bwmThreePrintCarInfo(string color, string brand, string type, int year) {
    string str = "车的品牌是：" + brand + ",型号是: " + type + ",颜色是：" + color + ",上市年限是:" + std::to_string(year);
    cout << str << endl;
}

void A6PrintCarInfo(string color, string brand, string type, int year) {
    string str = "车的品牌是：" + brand + ",型号是: " + type + ",颜色是：" + color + ",上市年限是:" + std::to_string(year);
    cout << str << endl;
}

int main() {
    Car BWMthree;
    BWMthree.color = "白色";
    BWMthree.brand = "宝马";
    BWMthree.type = "3系";
    BWMthree.year = 2023;
    BWMthree.pwl = new Wheel();
    BWMthree.pwl->brand = "米其林";
    BWMthree.pwl->year = 2023;
    BWMthree.printCarInfo = bwmThreePrintCarInfo;
    BWMthree.printCarInfo(BWMthree.color, BWMthree.brand, BWMthree.type, BWMthree.year);
    BWMthree.realPrintCarInfo();

    Car *AodiA6 = new Car();
    AodiA6->color = "黑色";
    AodiA6->brand = "奥迪";
    AodiA6->type = "A6";
    AodiA6->year = 2008;
    AodiA6->printCarInfo = A6PrintCarInfo;
    AodiA6->pwl = new Wheel();
    AodiA6->pwl->brand = "普利司通";
    AodiA6->pwl->year = 2012;
    AodiA6->printCarInfo(AodiA6->color, AodiA6->brand, AodiA6->type, AodiA6->year);
    AodiA6->realPrintCarInfo();
    AodiA6->pwl->wheelPrintInfo();
    return 0;
}

希望这篇整理的博文对您有帮助！