class 把数据和操作塞进同一个名字里,同时给了编译器一条边界:哪些成员从外面能碰,哪些只能从类内部碰。这两件事在语法上只占几行,但决定了后面所有成员函数怎么写、对象有多大、函数调用时多传了什么。

类体、分号与命名惯例

#include <iostream>
 
class Date
{
public:
    void Init(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
 
    void Print()
    {
        std::cout << _year << '-' << _month << '-' << _day << '\n';
    }
 
private:
    int _year;
    int _month;
    int _day;
};
 
int main()
{
    Date d;
    d.Init(2024, 3, 31);
    d.Print();
    return 0;
}

class 是关键字,Date 是类名,花括号里是类体,结尾的分号不能省——这个分号是定义的一部分,漏掉之后下一行会被当成成员声明继续解析。类体里的变量叫成员变量(属性),函数叫成员函数(方法)。

成员变量常带一个标识符,比如 _year 或者 m_year,目的是让形参和成员变量在函数体里能一眼分开。这只是惯例,标准没有任何要求,具体看团队规范。

C++ 里 struct 也能定义类,并且比 C 多两条:可以在里面定义函数;结构体名直接就是类型名,不用再写 typedef。

struct ListNodeC
{
    struct ListNodeC* next;
    int val;
};
 
struct ListNodeCPP
{
    void Init(int x)
    {
        next = nullptr;
        val = x;
    }
 
    ListNodeCPP* next;
    int val;
};

ListNodeC 是 C 的写法,C 里类型名要写 struct ListNodeC,所以习惯再配一个 typedef 给结构体起别名;ListNodeCPP 定义完,ListNodeCPP 这个名字就能直接用。定义类一般还是用 class,struct 留给需要兼容 C 的场景。

类体里直接写函数体的成员函数,隐式就是 inline 的。这一点在讲内联时还会遇到:写在类里的短函数天然带内联建议,挪到类外定义就没有这个待遇。

访问限定符给编译器划的是一条边界

访问限定符的三个分支:public、private、protected。三者都是成员声明前缀,区别只在“类外能不能直接访问”

  • public 修饰的成员在类外可以直接访问。
  • private 和 protected 修饰的成员在类外不能直接访问,这两个在继承之前没有区别,差别要到继承那一讲才显现。
  • 权限的作用范围从限定符出现的位置开始,到下一个限定符出现为止;后面没有限定符,就一直延伸到类体的 }。
  • class 定义的类,没写限定符的成员默认 private;struct 默认 public。

一般把成员变量放 private,把需要外部调用的成员函数放 public。这就是封装在这一层能看到的全部:对象的数据只能通过类自己给的接口改,外部拿不到 _year 这个字段,也就不会绕过 Init 直接乱写。

课件那句话“C++ 一种实现封装的方式,用类将对象的属性与方法结合在一块”,主语丢了。准确说是:访问限定符是实现封装的手段,把数据和行为放进同一个类只是前提。

类域:类外定义成员,Stack:: 不是装饰

类定义了一个新的作用域,所有成员都在这个域里。类外定义成员函数时必须带限定名:

#include <cstddef>
#include <cstdio>
#include <cstdlib>
 
class Stack
{
public:
    void Init(int n = 4);
 
private:
    int* _a;
    std::size_t _capacity;
    std::size_t _top;
};
 
void Stack::Init(int n)
{
    _a = (int*)malloc(sizeof(int) * n);
    if (_a == nullptr)
    {
        std::perror("malloc fail");
        return;
    }
    _capacity = n;
    _top = 0;
}
 
int main()
{
    Stack st;
    st.Init();
    return 0;
}

把 Stack:: 去掉,编译器会认为在全局域定义了一个普通函数 Init。这时函数体里的 _a 是全局找不到的名字,编译期直接报“未声明的标识符”;就算把 _a 换成全局变量,st.Init() 也会因为成员函数只有声明没有定义而在链接阶段失败。限定名的作用是告诉编译器:这个名字属于 Stack 这个域,域里找不到的名字再去类域里找。

这一点和命名空间不同。命名空间可以用 using 展开,类域不能,类成员只能通过 对象.成员、对象指针->成员 或者类外定义时的 类名::成员 三种方式碰。

实例化:类只是布局说明,对象才有空间

左边一个“类”分出多个“实例化对象”,右边一张建筑设计图对应多栋房子;看箭头方向,一个类可以对应任意多个对象,图纸本身住不了人

类里的成员变量在类定义阶段只是声明,不分配空间。用类这种类型在内存里创建对象的过程叫实例化,实例化出来的对象才占空间、才能存数据。一个类可以实例化任意多个对象,每个对象有自己独立的一份成员变量。

sizeof(Stack) 这种写法仍然合法,因为对象布局在编译期就确定下来了,编译器不需要真的创建一个对象就能算出大小。这不代表类定义时已经开了空间。

对象大小:只有成员变量进对象

成员函数编译后是一段指令,存在代码段里,对象装不下;如果非要在对象里存,只能存函数指针。但同一个类的所有对象调用的都是同一份函数,d1 和 d2 存两份一样的函数指针纯属浪费,实例化一百个对象就重复一百次。而且函数调用在编译链接阶段就把地址算好了,汇编里是一条 call 地址,运行时不需要再查;只有动态多态才需要在运行时找函数地址,那要等到虚函数那一讲。

“对象存储方式设计一”:成员变量和成员函数都放进每个对象。这样每个对象都要复制一份函数体地址,实例化越多浪费越多,是错误的设计

正确的布局:每个对象只放自己的成员变量,成员函数统一放在公共代码区。这也解释了为什么 sizeof 只算成员变量

对象里只剩成员变量,这些变量还要按内存对齐规则排:

  • 第一个成员放在偏移 0 的位置。
  • 后面的成员要对齐到“对齐数”的整数倍地址上。
  • 对齐数取编译器默认对齐数和该成员大小的较小值,VS 默认是 8。
  • 结构体总大小是最大对齐数的整数倍。
  • 嵌套结构体时,内层结构体对齐到它自己的最大对齐数,整体大小仍按所有最大对齐数取整。
#include <iostream>
 
class A
{
public:
    void Print()
    {
        std::cout << _ch << '\n';
    }
 
private:
    char _ch;
    int _i;
};
 
class B
{
public:
    void Print()
    {
        std::cout << "B::Print()" << '\n';
    }
};
 
class C
{
};
 
int main()
{
    A a;
    B b;
    C c;
    std::cout << sizeof(a) << ' ' << sizeof(b) << ' ' << sizeof(c) << '\n';   // 8 1 1
    return 0;
}

A 里 _ch 占 1 字节,_i 的对齐数是 4,要挪到偏移 4,中间补 3 字节,总大小 8。B 和 C 没有成员变量,大小仍是 1:完整对象的大小至少是 1 字节,这样同类型的两个不同对象才能拿到不同地址,不会互相重叠。

嵌套结构体用的是同一条规则,但要把内层的对齐数带上来:

#include <iostream>
 
struct Inner
{
    int a;
    double b;
};
 
struct Outer
{
    char c;
    Inner in;
};
 
int main()
{
    std::cout << sizeof(Inner) << ' ' << sizeof(Outer) << '\n';   // 16 24
    return 0;
}

Inner 里 a 占 4 字节,b 的对齐数是 8,整体大小升到 16。Outer 的 c 占偏移 0,in 要按 8 对齐,落到偏移 8,占 16 字节,总大小 24。外层结构体的对齐数取它所有成员对齐数的最大值,嵌套结构体自身也算一个成员,带着自己的对齐数参与比较。

成员的排列顺序也会改变结果。struct S1 { char a; double b; char c; }; 占 24 字节:a 在偏移 0,补 7 字节,b 在偏移 8,c 在偏移 16,末尾再补 7 字节凑到 24。把两个 char 相对位置换一下,struct S2 { double b; char a; char c; }; 只有 16 字节。成员的字节数两者都是 10,sizeof 却差 8,所以 sizeof 不等于成员字节数相加。

课件说“C++ 规定类实例化的对象也要符合内存对齐的规则”,严格讲对齐数、填充位置由编译器遵循的 ABI 决定,标准只保证同一访问区里的成员按声明顺序排列、每个成员按自身对齐要求放置。VS 的默认对齐数是 8,可以用 #pragma pack 改;换编译器、换平台,同一段代码的 sizeof 可能不一样。

this 指针是隐式第一个形参

d1.Init(2024, 3, 31) 和 d2.Init(2024, 7, 5) 调用的是同一个函数,函数体里没有任何地方区分对象,它凭什么知道给哪个对象的 _year 赋值?

#include <iostream>
 
class Date
{
public:
    // 真实原型:void Init(Date* const this, int year, int month, int day)
    void Init(int year, int month, int day)
    {
        // this = nullptr;        // 错:error C2106,“=”左操作数必须为左值
        _year = year;            // 等价于 this->_year = year;
        this->_month = month;
        this->_day = day;
    }
 
    void Print()
    {
        std::cout << _year << '-' << _month << '-' << _day << '\n';
    }
 
private:
    int _year;
    int _month;
    int _day;
};

编译器给每个非静态成员函数在形参表最前面加一个当前类类型的指针,就是 this。this 的类型是 Date* const:指针本身不能改,指向的对象可以改,所以 this = nullptr 编不过。形参和实参位置都不能手写 this,编译器自己会把对象地址传进去,函数体里可以显式用它。

两道常见的判断题:

class A
{
public:
    void Print()
    {
        std::cout << "A::Print()" << '\n';
    }
private:
    int _a;
};
 
int main()
{
    A* p = nullptr;
    p->Print();          // 多数实现上正常打印
    return 0;
}

Print 没有访问任何成员,函数体内没有解引用 this,所以空指针调用在常见实现上会正常打印。按标准,对空指针调用成员函数属于未定义行为,只是这条路径恰好没有踩到空地址。

把 Print 改成输出 _a,同一段代码就会崩:this->_a 要读地址 0 附近的内存。

this 存在哪里?它不是一个藏在对象里的字段,而是一个隐含形参。作为形参,它跟着调用约定走:x64 上 MSVC 用 RCX 传,x86 的 thiscall 用 ECX 传,寄存器放不下或需要取地址时才落到栈上。把它当成“一定在栈上”的选择题答案并不严谨,能排除的是“存在对象里面”。

从 C 的 Stack 到 C++ 的 Stack

同一个栈,C 版本是一组自由函数,每个都要接收对象地址:

#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
 
typedef int STDataType;
typedef struct Stack
{
    STDataType* a;
    int top;
    int capacity;
} ST;
 
void STInit(ST* ps)
{
    ps->a = NULL;
    ps->top = 0;
    ps->capacity = 0;
}
 
void STDestroy(ST* ps)
{
    free(ps->a);
    ps->a = NULL;
    ps->top = ps->capacity = 0;
}
 
void STPush(ST* ps, STDataType x)
{
    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;
}
 
bool STEmpty(ST* ps)
{
    return ps->top == 0;
}
 
void STPop(ST* ps)
{
    assert(!STEmpty(ps));
    ps->top--;
}
 
STDataType STTop(ST* ps)
{
    assert(!STEmpty(ps));
    return ps->a[ps->top - 1];
}

C++ 版本把函数搬进类里,数据加访问限定:

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <cstddef>
 
typedef int STDataType;
 
class Stack
{
public:
    void Init(int n = 4)
    {
        _a = (STDataType*)malloc(sizeof(STDataType) * n);
        if (_a == nullptr)
        {
            std::perror("malloc fail");
            return;
        }
        _capacity = n;
        _top = 0;
    }
 
    void Push(STDataType x)
    {
        if (_top == _capacity)
        {
            int newcapacity = _capacity == 0 ? 4 : _capacity * 2;
            STDataType* tmp = (STDataType*)realloc(_a, newcapacity * sizeof(STDataType));
            if (tmp == nullptr)
            {
                std::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;
    std::size_t _capacity;
    std::size_t _top;
};
 
int main()
{
    Stack s;
    s.Init();
    s.Push(1);
    s.Push(2);
    s.Push(3);
    s.Push(4);
 
    while (!s.Empty())
    {
        std::cout << s.Top() << '\n';
        s.Pop();
    }
 
    s.Destroy();
    return 0;
}

形态上的变化有四条:数据与函数进了同一个类,访问限定符挡住了外部对 _a、_top 的乱改;每次调用不再传对象地址,this 隐式传了;Init 用缺省参数一次开好容量;类名就是类型名,不用再 typedef。底层逻辑没变:还是 malloc、realloc 加一个下标。

课件前面那个类版本的 Push 里只写了扩容的注释,按注释补全时要处理三件事:realloc 失败不能直接覆盖 _a,必须先用临时指针接住再写回;容量从 0 起步时 _capacity * 2 仍然是 0,要么给三元表达式兜底,要么在 Init 里保证容量大于 0;_capacity 和 _top 用 std::size_t 时,Init(int n) 的 n 要先确认非负再转换。