当前位置： 首页 > news >正文

从零开始的C++学习生活 2:类和对象(上)

news 2025/10/5 6:23:30

前言

C语言是一门面向过程的语言，强调函数和过程化编程。

而我们学习的C++既保留了C的传统，也支持面向对象，泛型等多种范式的混合式编程语言。

那么本文我们将学习C++极其重要的一个新知识点:类

1. 类的定义

类是一种用户自定义的数据类型，它封装了数据（成员变量）和操作数据的方法（成员函数）。

类实际上很像C语言中的结构体，能够包含多种数据变量，但不同的是类可以封装函数，也可以把成员变量设置成公有或私有

2 类定义格式

• class为定义类的关键字，Stack为类的名字，{}中为类的主体，注意类定义结束时后⾯分号不能省 略。类体中内容称为类的成员：类中的变量称为类的属性或成员变量;类中的函数称为类的⽅法或 者成员函数。

• 为了区分成员变量，⼀般习惯上成员变量会加⼀个特殊标识，如成员变量前⾯或者后⾯加_或者m 开头，注意C++中这个并不是强制的，只是⼀些惯例，具体看公司的要求。

• C++中struct也可以定义类，C++兼容C中struct的⽤法，同时struct升级成了类，明显的变化是 struct中可以定义函数，⼀般情况下我们还是推荐⽤class定义类。

• 定义在类里面的成员函数默认为inline。

#include <iostream>
using namespace std;// 基本的类定义
class Stack {
public:// 成员函数void Init(int n = 4) {...}void Push(int x) {...}int Top() {...}void Destroy() {...}private:// 成员变量int* _array;size_t _capacity;size_t _top;
};  // 注意：类定义结束必须有分号

3 访问限定符

C++⼀种实现封装的方式，用类将对象的属性与方法结合在⼀块，让对象更加完善，通过访问权限 选择性的将其接口提供给外部的用户使用。

类中可用public，private和protected来修饰成员变量

public修饰可在类外进行访问，而private和protected修饰的成员变量无法在类外进行访问，只能在类内进行访问

class定义成员没有被访问限定符修饰时默认为private，struct默认为public。

 ⼀般成员变量都会被限制为private/protected，需要给别⼈使⽤的成员函数会放为public。

class Example {
public:        // 公有成员 - 类外可以直接访问void PublicFunc() {// 可以访问所有成员publicVar = 1;privateVar = 2;protectedVar = 3;}protected:     // 保护成员 - 类外不能访问，派生类可以访问int protectedVar;private:       // 私有成员 - 只有本类可以访问int privateVar;public:int publicVar;
};int main() {Example obj;obj.publicVar = 10;      // 正确：公有成员// obj.privateVar = 20;  // 错误：私有成员不能在类外访问// obj.protectedVar = 30;// 错误：保护成员不能在类外访问obj.PublicFunc();        // 正确：公有成员函数return 0;
}

4 成员变量的访问

类的成员变量的访问类似于结构体访问成员变量，即利用.或->操作符来访问，一般使用.操作符来访问

int main() {Stack st;st.Init();st.Push(1);st.Push(2);cout << st.Top() << endl;st.Destroy();return 0;
}

5 类域

类定义了⼀个新的作用域，类的所有成员都在类的作用域中，在类体外定义成员时，需要使用::作 用域操作符指明成员属于哪个类域。

类域影响的是编译的查找规则，下⾯程序中Init如果不指定类域Stack，那么编译器就把Init当成全 局函数，那么编译时，找不到array等成员的声明/定义在哪⾥，就会报错。指定类域Stack，就是知 道Init是成员函数，当前域找不到的array等成员，就会到类域中去查找。

#include <iostream>
using namespace std;class Stack {
public:// 函数声明void Init(int n = 4);void Push(int x);int Top();void Destroy();private:int* _array;size_t _capacity;size_t _top;
};// 类外定义成员函数 - 必须指定类域
void Stack::Init(int n) {//实现代码...
}void Stack::Push(int x) {// 实现代码...
}int Stack::Top() {return _array[_top - 1];
}void Stack::Destroy() {free(_array);_array = nullptr;_top = _capacity = 0;
}int main() {Stack st;st.Init();      // 调用成员函数st.Push(1);cout << st.Top() << endl;st.Destroy();return 0;
}

6 类的实例化

类根结构体十分相似。结构体可以看作是一张图纸，我们按照这个图纸创建多个对象，就像建房子一样，但图纸中的内容并不真实存在，只是我们假象然后按照这个假象创造出来实物

类也同样如此。类是对象进⾏⼀种抽象描述，是⼀个模型⼀样的东西，限定了类有哪些成员变量，这些成员变量只 是声明，没有分配空间，⽤类实例化出对象时，才会分配空间。

class Date {
public:void Init(int year, int month, int day) {_year = year;_month = month;_day = day;}void Print() {cout << _year << "/" << _month << "/" << _day << endl;}private:int _year;      // 这里只是声明，没有分配内存int _month;int _day;
};int main() {// 实例化对象 - 此时才分配内存Date d1;Date d2;d1.Init(2024, 3, 31);d1.Print();d2.Init(2024, 7, 5); d2.Print();return 0;
}

类比理解：

  • 类 = 建筑设计图

  • 对象 = 根据设计图建造的实际房子

  • 实例化 = 按设计图施工的过程

对象大小

类和结构体的计算大小方式相同，但成员函数不算大小

对象大小只包含成员变量，不包含成员函数。

内存对齐规则

• 第⼀个成员在与结构体偏移量为0的地址处。

• 其他成员变量要对⻬到某个数字（对⻬数）的整数倍的地址处。

• 注意：对⻬数=编译器默认的⼀个对⻬数与该成员⼤⼩的较⼩值。

• VS中默认的对⻬数为8 • 结构体总⼤⼩为：最⼤对⻬数（所有变量类型最⼤者与默认对⻬参数取最⼩）的整数倍。

• 如果嵌套了结构体的情况，嵌套的结构体对齐到⾃⼰的最⼤对⻬数的整数倍处，结构体的整体大小就是所有最⼤对⻬数（含嵌套结构体的对齐数）的整数倍。

#include <iostream>
using namespace std;class A {
public:void Print() {cout << _ch << endl;}
private:char _ch;   // 1字节int _i;     // 4字节// 由于内存对齐，总大小为8字节
};class B {
public:void Print() {// 空函数}// 没有成员变量
};class C {// 完全空类
};int main() {A a;B b; C c;cout << "A的大小: " << sizeof(a) << endl;  // 8cout << "B的大小: " << sizeof(b) << endl;  // 1  cout << "C的大小: " << sizeof(c) << endl;  // 1return 0;
}

为什么空类大小为1？

  • 如果空类大小为0，多个空类对象会有相同地址

  • 分配1字节是为了标识对象的存在，保证每个对象有唯一地址

7 this指针

Date类中有Init与Print两个成员函数，函数体中没有关于不同对象的区分，那当d1调⽤Init和 Print函数时，该函数是如何知道应该访问的是d1对象还是d2对象呢？那么这⾥就要看到C++给了 ⼀个隐含的this指针解决这⾥的问题

this指针是类中自带的隐含的指针，放在函数的第一个形参位置，但是不会显示出来，我们也不用专门地去添加。

类的成员函数中访问成员变量，本质都是通过this指针访问的，如Init函数中给_year赋值， this->_year = year

C++规定不能在实参和形参的位置显⽰的写this指针(编译时编译器会处理)，但是可以在函数体内显 ⽰使⽤this指针。

#include <iostream>
using namespace std;class Date {
public:// 编译器会将函数转换为：void Init(Date* const this, int year, int month, int day)void Init(int year, int month, int day) {// this指针是隐含的，不能在参数中显式写出// 但可以在函数体内使用// 以下三种写法等价：_year = year;           // 方式1：隐式使用thisthis->_month = month;   // 方式2：显式使用thisthis->_day = day;       // 方式3：显式使用this}void Print() {cout << _year << "/" << _month << "/" << _day << endl;}private:int _year;int _month; int _day;
};int main() {Date d1, d2;// 编译器会将调用转换为：d1.Init(&d1, 2024, 3, 31);d1.Init(2024, 3, 31);d2.Init(2024, 7, 5);d1.Print();  // 输出：2024/3/31d2.Print();  // 输出：2024/7/5return 0;
}

this指针的特性

  • 类型：类型* const（常量指针）

  • 自动传递：编译器自动在成员函数参数中添加

  • 不可修改：不能改变this指针的指向

  • 隐式使用：通常不需要显式写出

C++与C语言实现Stack的对比

C语言实现

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>typedef int STDataType;
typedef struct Stack {STDataType* a;int top;int capacity;
} ST;void STInit(ST* ps) {assert(ps);ps->a = NULL;ps->top = 0;ps->capacity = 0;
}void STDestroy(ST* ps) {assert(ps);free(ps->a);ps->a = NULL;ps->top = ps->capacity = 0;
}void STPush(ST* ps, STDataType x) {assert(ps);// 扩容检查if (ps->top == ps->capacity) {int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));if (tmp == NULL) {perror("realloc fail");return;}ps->a = tmp;ps->capacity = newcapacity;}ps->a[ps->top] = x;ps->top++;
}bool STEmpty(ST* ps) {assert(ps);return ps->top == 0;
}void STPop(ST* ps) {assert(ps);assert(!STEmpty(ps));ps->top--;
}STDataType STTop(ST* ps) {assert(ps);assert(!STEmpty(ps));return ps->a[ps->top - 1];
}int STSize(ST* ps) {assert(ps);return ps->top;
}int main() {ST s;STInit(&s);STPush(&s, 1);STPush(&s, 2);STPush(&s, 3);STPush(&s, 4);while (!STEmpty(&s)) {printf("%d\n", STTop(&s));STPop(&s);}STDestroy(&s);return 0;
}

C++实现

#include <iostream>
using namespace std;typedef int STDataType;class Stack {
public:// 成员函数void Init(int n = 4) {_a = (STDataType*)malloc(sizeof(STDataType) * n);if (nullptr == _a) {perror("malloc申请空间失败");return;}_capacity = n;_top = 0;}void Push(STDataType x) {if (_top == _capacity) {int newcapacity = _capacity * 2;STDataType* tmp = (STDataType*)realloc(_a, newcapacity * sizeof(STDataType));if (tmp == NULL) {perror("realloc fail");return;}_a = tmp;_capacity = newcapacity;}_a[_top++] = x;}void Pop() {assert(_top > 0);--_top;}bool Empty() {return _top == 0;}STDataType Top() {assert(_top > 0);return _a[_top - 1];}void Destroy() {free(_a);_a = nullptr;_top = _capacity = 0;}private:// 成员变量STDataType* _a;size_t _capacity;size_t _top;
};int main() {Stack s;s.Init();s.Push(1);s.Push(2);s.Push(3);s.Push(4);while (!s.Empty()) {printf("%d\n", s.Top());s.Pop();}s.Destroy();return 0;
}

对比分析

特性C语言实现C++实现优势
数据封装结构体数据完全暴露数据私有，通过接口访问更安全
函数调用需要显式传递对象指针自动传递this指针更简洁
初始化需要单独调用初始化函数可使用缺省参数更灵活
类型使用需要typedef类名直接作为类型更直观
内存管理手动管理可在类中封装管理逻辑更安全

总结

  1. 类的定义：使用class关键字定义类，包含成员变量和成员函数

  2. 访问控制：通过public、private、protected实现封装

  3. 类的作用域：类定义新的作用域，类外定义需使用::

  4. 对象实例化：类不占内存，实例化对象时才分配空间

  5. 对象大小：只包含成员变量，遵循内存对齐规则

  6. this指针：隐含指针，标识当前对象，解决成员函数区分问题

  7. 封装优势：提高安全性、简化接口、便于维护

面向对象编程的核心思想是封装——将数据和对数据的操作封装在一起，对外提供统一的接口。这种思维方式让我们能够构建更复杂、更健壮的系统。

在下一章中，我们将深入学习类的其他重要特性：构造函数、析构函数、拷贝构造等，进一步体会面向对象编程的强大之处。

http://www.dtcms.com/a/442157.html

相关文章：

  • 家纺营销型网站网站建设服务费怎么记账
  • css其他选择器（精细修饰）
  • 一般设计网站页面用什么软件做引擎网站
  • 生成式 AI 重构内容创作：从辅助工具到智能工厂
  • 华为S5720配置telnet远程
  • 面试复盘：哔哩哔哩、蔚来、字节跳动、小红书面试与总结
  • Your ViT is Secretly an Image Segmentation Model
  • 海口网站建设运营网站开发公司选择
  • 日语学习-日语知识点小记-进阶-JLPT-N1阶段应用练习（4）：语法 ＋考え方１7+2022年7月N1
  • RAG：解锁大语言模型新能力的关键钥匙
  • 广州网站建设海珠信科网站建设推广方法
  • Oracle Linux 7.8 静默安装 Oracle 11g R2 单机 ASM 详细教程
  • 旅游公司网站建设方案网站的布局结构三种
  • Django ORM 无法通过 `ForeignKey` 自动关联，而是需要 **根据父模型中的某个字段（比如 ID）去查询子模型**。
  • 吉林省建设厅信息网站网站建设的评价
  • 分布式专题——26.5 一台新机器进行Web页面请求的历程
  • 怎么让别人看到自己做的网站万维网网站301重定向怎么做
  • css样式学习记录
  • 网站服务器关闭网站数据库地址是什么
  • 每日一个C语言知识：C程序结构
  • Amazon RDS：云端数据库管理的革新之路
  • wordpress登录可见站内seo是什么意思
  • STM32简单的串口Bootloader入门
  • 360网站怎么做2核4g做网站
  • 从 “手工作坊” 到 “智能工厂”：2025 年 AI 原生应用重构内容创作产业
  • 做网站平台难在哪里网页翻译不见了
  • Flutter技术栈深度解析：从架构设计到性能优化
  • 学做湘菜的视频网站中国建设企业银行登录网站
  • 【Python进阶】网络爬虫核心技能-第三方IP服务
  • CAS密钥管理系统在汽车行业的核心密钥管理实践——构建智能网联汽车的可信安全底座