C++——类

最新推荐文章于 2024-06-02 11:06:10 发布
最新推荐文章于 2024-06-02 11:06:10 发布
阅读量824 收藏 14
点赞数 11
分类专栏： C++ 文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47944751/article/details/135991227
版权

C++——类

类的初探

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

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

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

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

  3. 构造函数和析构函数：特殊的成员函数。构造函数在创建对象时自动调用，用于初始化对象。析构

函数在对象销毁时调用，用于执行清理操作。

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

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

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

通过这些特性，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++中，字符串用string来表示，发现有个string赋值给char 的警告，所以修改所有**char *为string类型

main.cpp:33:17: warning: ISO C++11 does not allow conversion from string literal
to 'char *'
    • 修改后，发现printf的%s控制位，不能用于string的输出，所有有string构建了即将要输出的字符串
    • C++中，通过std::tostring()函数，将整型数转化成字符串
    • 在printInfo中使用cout输出汽车信息
    • 发现在C++工程中，使用malloc在堆申请结构体空间有问题，所以直接在此引入类的概念，把struct改成class
    • 引入新问题，class的成员数据和成员函数在不指定权限的情况下，默认private权限，类的对象无法进行直接访问
  • main.cpp:33:9: error: 'color' is a private member of 'Car'
main.cpp:5:11: note: implicitly declared private here

  • 添加public属性

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  • 把main函数中的原本结构体变量改成了类的实例化，如果变量类型是指针，把原来的malloc改成new一个对象
  • 最后解决了所有问题
#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 = (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;
}

但是!我们还没真正体验到面向对象的封装特性，仅仅感受到权限的区别

真正的成员函数

  • void (*printCarInfo)(string color,string brand,string type, intyear); 到底是变量函数函数呢？
  • 是一个指针变量，是保存某个函数地址的变量，所以它不是成员函数，是成员数据
  • 真正的成员函数遵守封装特性，在函数体内部访问成员数据的时候，不需要参数传递
  • 在 C++ 中，双冒号 :: 称为 “作用域解析运算符”（Scope Resolution Operator）。它用于指定一个成员（如函数或变量）属于特定的类或命名空间。例如，在类的外部定义成员函数时， :: 用于指明该函数属于哪个类。
#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 = (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);
    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;
}
//在 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;
}

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;

}
my hope !
关注
  • 11
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++——万能头文件。
04-09
万能头文件 万能头文件就是一个包含几乎所有的头文件，如： #include #include #include #include #include <cmath> #include <deque> #include <vector> #include <queue> ...#include <bits/stdc++.h>
C++——数组模拟链表
12-03
C++数据结构——链表，适合初学者，使用数组模拟链表。
详解C++基础——类继承
08-26
主要介绍了C++类继承，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
c++——扫雷简单版9*9
03-22
c++实现扫雷
C++——HIS排班系统for Neuedu
04-20
东软云HIS医院管理系统基础信息维护模块
C++：round函数用法
Solititude的博客
05-28 373
C++：round函数用法
c++ string模拟实现
2302_81705247的博客
06-01 568
模拟实现string类，里面包含四个成员变量，第一个是指向字符数组的指针，第二个变量是目前存放了多少个字符，第三个变量为这个字符数组的容量的大小。最后一个为静态成员变量npos。注意：一个修饰的成员变量可以在类里面初始化（三者缺一不可），而其他成员变量，要声明定义分离，类中声明，类外定义。char* _str;
精通C++ STL（二）：string类的模拟实现
Russ_Leo的博客
05-27 846
string类各函数接口。
【如何利用c++RAII技术实现自动加解锁】
逆风飞翔的博客
05-28 345
使用C++中的 RAII（资源获取即初始化）技术来实现自动加锁解锁
无向图中两点(x1,y1)(x2,y2)是否连通(bfs&并查集)两种方法解决(c++)
weixin_73886306的博客
05-30 374
无向图中两点(x1,y1)(x2,y2)是否连通(bfs&并查集)两种方法解决(c++)
【C++】问题及补充（2）
2301_80207207的博客
05-30 878
vector和list都是C++ STL中的容器，它们被定义在不同的头文件中。vector在中定义，而list在中定义。因此，如果要使用它们，需要包含相应的头文件。通常情况下，C++中的类定义需要包含在头文件中，而类的实现则包含在源文件中。这样做的目的是为了避免在多个源文件中重复定义同一个类，从而引发编译错误。因此，在C++ STL中，vector和list的定义也需要写在头文件中，以便在需要使用它们的源文件中包含相应的头文件即可。
2024华为OD机试真题-最长子字符串的长度（一）-C++-OD统一考试（C卷D卷）
goldarmour的博客
05-29 114
给你一个字符串 s，首尾相连成一个环形，请你在环中找出 'o' 字符出现了偶数次最长子字符串的长度。输入是一个小写字母组成的字符串，输出是一个整数
C语言:从键盘输入若干行字符（每行长度不等），输入后把它们存储到一磁盘文件中。再从该文件中读入这些数据，将其中小写字母转换成大写字母后在显示屏上输出。
2305_78057683的博客
05-29 194
C语言:从键盘输入若干行字符（每行长度不等），输入后把它们存储到一磁盘文件中。再从该文件中读入这些数据，将其中小写字母转换成大写字母后在显示屏上输出。
C是结构化编程语言吗：深度剖析与多维度解读
最新发布
liyrbtqe_66w的博客
06-02 248
结构化编程强调将程序划分为一系列独立的、可重用的函数或模块，每个模块都执行特定的任务。与面向对象编程范式相比，C语言更注重过程和函数的组织，而不是对象和类的概念。在编程语言的浩瀚海洋中，C语言以其独特的魅力占据着重要的地位。然而，要全面评价C语言是否属于结构化编程语言，还需要考虑其在实际应用中的表现。在这些领域中，C语言的结构化特性得到了充分的体现。通过结构化编程的方式，开发人员可以将这些功能划分为独立的模块，提高系统的稳定性和可维护性。它支持结构化编程的基本理念，具有清晰明了的语法和强大的实际应用能力。
【华为OD机试-C卷D卷-200分】篮球游戏(C++/Java/Python)
goldarmour的博客
05-28 397
​幼儿园里有一个放倒的圆桶，它是一个线性结构，允许在桶的右边将篮球放入，可以在桶的左边和右边将篮球取出。每个篮球有单独的编号，老师可以连续放入一个或多个篮球，小朋友可以在桶左边或右边将篮球取出，当桶只有一个篮球的情况下，必须从左边取出。
C语言 入门例子和代码学习
m0_67912929的博客
06-02 284
while (fgets(buffer, sizeof(buffer), file)) { // 循环读取文件直到文件末尾。// 打印 "You are an adult."printf("Value of number: %d\n", number);// 打印 number 的值。
一维数组基础（题目+答案）
mayuteng1的博客
05-27 1321
一维数组基础（题目+答案）
C++ final 和 override
CH3CH2CH4的博客
05-27 205
override：用于显式地指出一个成员函数是重写基类中的虚函数。这有助于提高代码的可读性和安全性，因为编译器会检查函数是否正确地重写了基类的虚函数。final：用于指定一个类不能被继承，或者一个虚函数不能被子类重写。这有助于保护类的设计，防止意外的修改。
2024华为OD机试真题-查找接口成功率最优时间段-C++(C卷D卷)
goldarmour的博客
06-01 53
服务之间交换的接口成功率作为服务调用关键质量特性，某个时间段内的接口失败率使用一个数组表示，数组中每个元素都是单位时间内失败率数值，数组中的数值为0~100的整数， 给定一个数值(minAverageLost)表示某个时间段内平均失败率容忍值，即平均失败率小于等于minAverageLost，
桥接模式 C++——
05-28
桥接模式的核心思想是将一个大类或一组类分解成抽象和实现两个独立的维度，使它们可以独立地变化和扩展，同时通过桥接来将它们连接起来。 在C++中，桥接模式通常通过虚函数实现。抽象部分通过基类定义接口，而实现...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值