QT篇：类

一.类的初探

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

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

1. 数据成员（Attributes）：定义类的属性。这些是类内部的变量，用于存储对象的状态。

2. 成员函数（Methods）：定义类的行为。这些是可以操作对象的数据成员的函数。

3. 构造函数和析构函数：特殊的成员函数。构造函数在创建对象时自动调用，用于初始化对象。析构 函数在对象销毁时调用，用于执行清理操作。

4. 访问修饰符：如 public , private , protected ，用于控制对类成员的访问权限。例如， public

成员可以在类的外部访问，而 private 成员只能在类内部访问。

5. 继承：允许一个类继承另一个类的特性。这是代码重用和多态性的关键。

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

二.结构体引入类

1.如果用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;
}

2.新建C++工程来使用结构体

在C++中，字符串用string来表示，发现有个string赋值给char 的警告，所以修改所有char *为

string类型

修改后，发现printf的%s控制位，不能用于string的输出，所有有string构建了即将要输出的字符串

C++中，通过std::tostring()函数，将整型数转化成字符串 在printInfo中使用cout输出汽车信息 发现在C++工程中，使用malloc在堆申请结构体空间有问题，所以直接在此引入类的概念，把struct

改成class

引入新问题，class的成员数据和成员函数在不指定权限的情况下，默认private权限，类的对象无法 进行直接访问

添加public属性

 

 

把main函数中的原本结构体变量改成了类的实例化，如果变量类型是指针，把原来的malloc改成

new一个对象 最后解决了所有问题

3.QT中经常出现的用法

在 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;
}

//在 C++中，一个类包含另一个类的对象称为组合（Composition）。

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.wl.brand = "米其林";

    //BWMthree.wl.year = 2023;

    BWMthree.printCarInfo = bwmThreePrintCarInfo;
   
 BWMthree.printCarInfo(BWMthree.color,BWMthree.brand,BWMthree.type,BWMthree.year)
;
    BWMthree.realPrintCarInfo();
    //BWMthree.wl.wheelPrintInfo();
 Car *AodiA6 = new Car();
  // AodiA6 = (struct Car*)malloc(sizeof(struct 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->wl.brand = "马牌";

    //AodiA6->wl.year = 2023;

    AodiA6->printCarInfo(AodiA6->color,AodiA6->brand,AodiA6->type,AodiA6->year);
    AodiA6->realPrintCarInfo();
    //AodiA6->wl.wheelPrintInfo();

    AodiA6->pwl->wheelPrintInfo();
    return 0;
}