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

Yupureki2025-10-05 12:59

前言

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

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

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

1. 类的定义

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

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

2 类定义格式

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

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

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

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

cpp 复制代码 
#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。

cpp 复制代码 
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 成员变量的访问

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

cpp 复制代码 
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等成员，就会到类域中去查找。

cpp 复制代码 
#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 类的实例化

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

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

cpp 复制代码 
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 • 结构体总⼤⼩为：最⼤对⻬数（所有变量类型最⼤者与默认对⻬参数取最⼩）的整数倍。

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

cpp 复制代码 
#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;  // 8
    cout << "B的大小: " << sizeof(b) << endl;  // 1  
    cout << "C的大小: " << sizeof(c) << endl;  // 1
    
    return 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指针。

cpp 复制代码 
#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：隐式使用this
        this->_month = month;   // 方式2：显式使用this
        this->_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/31
    d2.Print();  // 输出：2024/7/5
    
    return 0;
}

this指针的特性

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

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

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

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

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

C语言实现

cpp 复制代码 
#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++实现

cpp 复制代码 
#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. 封装优势：提高安全性、简化接口、便于维护

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

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

相关推荐
羚羊角uou2 小时前
【Linux】线程的互斥
java·开发语言
mxd018482 小时前
最常用的js加解密之RSA-SHA256 加密算法简介与 jsjiami 的结合使用指南
开发语言·javascript·ecmascript
charlie1145141912 小时前
从《Life of A Pixel》来看Chrome的渲染机制
前端·chrome·学习·渲染·浏览器·原理分析
gopyer2 小时前
180课时吃透Go语言游戏后端开发7：Go语言中的函数
开发语言·游戏·golang·go·函数
来不及辣哎呀2 小时前
学习Java第三十天——黑马点评37~42
java·开发语言·学习
半桶水专家2 小时前
C语言中的setitimer函数详解
c语言·开发语言·算法
zhangfeng11333 小时前
R语言 安装老一点的班装包 核心是从CRAN归档（Archive）下载对应版本的安装包
开发语言·r语言
lbwxxc3 小时前
go 基础
开发语言·后端·golang
热门推荐
01HarmonyOS NEXT开发进阶（十四）：HarmonyOS应用开发者基础认证试题集汇总及答案解析02KGG转MP3工具|非KGM文件|解密音频03UV安装并设置国内源04GitHub 镜像站点05jdk21下载、安装（Windows、Linux、macOS）0646个Nano-banana 精选提示词，持续更新中07MIUI显示/隐藏5G开关的方法，信号弱时开启手机Wifi通话方法08Linux下V2Ray安装配置指南09零基础搭建赛博朋克个人主页：蓝耘Claude Code完整实战教程10最新b站加密关键字段的逆向（视频和评论爬取）