C与C++中struct和class的区别：从内存布局到面试考点深度解析

前几天有位做嵌入式开发的朋友给我看了一份C++岗位面经，第一题就是“请说说C和C++中struct和class的区别”。他自信满满答了“struct默认public，class默认private”，结果面试官不紧不慢追问：“如果限定在C语言里，struct还能有成员函数吗？你现在这句话还成立吗？”他当场卡住。

这个场景我见过太多次。很多人把这道题当成“背一个区别句”就完了，实际上面试官真正想听的，是你对C语言内存思维、C++面向对象演进、以及语言关键字背后设计意图的完整理解。今天这篇面试篇，我就把C的struct、C++的struct、C++的class三者之间的边界一次讲透，顺便把围绕它们的各种连环追问也一并梳理清楚。

1. 为什么招聘方最爱拿struct和class当“语言分水岭”

1.1 一个关键字能测出三种思维倾向

表面上你回答的是一道概念题，实际上面试官在通过这个问题判断：你是“只会写代码的同学”，还是“理解语言设计思路的工程师”。

如果只背了“struct默认public、class默认private”这句答案，最多只能证明你翻过教程。面试官真正想听的，是你脑子里有没有这样三条知识脉络：

• C语言中struct是一种“数据聚集工具”，它的价值主要体现在内存布局、字节对齐、硬件映射和跨模块数据传递；
• C++中struct被语言顺手改造了一下，保留C的聚合语义，又加入了成员函数、继承、访问控制等面向对象能力；
• class是C++在面向对象诉求下新增的关键字，和C++的struct相比只剩默认访问级别与默认继承方向这类细节差异。

这三层认知缺一层，遇到追问就容易露馅。比如“C语言里能不能在struct里放函数指针”“C++的struct能不能定义虚函数”“既然C++的struct和class这么像，为什么还要发明class”……这些都是从同一道题自然延伸出去的问题，不少面试官喜欢顺着你的回答往下挖。

1.2 你是面C岗还是面C++岗，答案重点完全不同

这道题的高明之处还在于，它能针对岗位灵活调整考察深度。

如果你应聘的是C语言开发或嵌入式岗位，面试官关心的绝不是C++的class默认继承细节，而是你是否理解C语言中struct在底层代表什么：一段连续的内存区域、一个可以映射到寄存器地址的数据模板、一个用于解释二进制缓冲区结构的协议载体。

如果你应聘的是C++岗位，面试官则希望你把C++的struct和class都当成“类”来分析，同时能解释清楚C++为什么没有抛弃struct这个历史关键字，反而赋予它接近class的能力。这一层能说清楚，通常说明你理解语言演进过程中的兼容性设计取舍。

我确实见过一些应聘者在这道题上栽跟头，问题基本都出在一上来就套“面向对象八股文”，而忽略了C语言本身是一个没有面向对象语法的过程式语言。C语言里压根没有class，所以当题目把C和C++并列提起时，你就要警觉：这道题实际是三个对象之间的比较，而不是简单两个关键字之间的比较。

2. C语言里的struct：没有对象能力，但有高级玩法

2.1 C的struct只能放数据，却把数据布局玩到极致

在C语言里，struct的语法意图非常单纯：把若干不同类型的数据打包成一个整体。它强调的是“数据的组织方式”，而不是“对象的行为”。

语法上，C语言不允许你在struct里声明成员函数。如果你写过这样的代码：

c复制struct Student {
    char name[32];
    int age;
    void print(); // 编译错误：C语言中不允许在结构体里声明函数
};

编译器会直接告诉你：这是非法的。C语言中函数和结构体是彻底分离的两个概念，这是过程式语言的典型特征。

不过，“不能声明成员函数”不代表C程序员没有自己的办法。实际工程里，我们经常使用函数指针成员，让结构体看起来带上一点“行为”：

c复制#include <stdio.h>
#include <string.h>

struct Logger {
    char name[32];
    void (*log)(const char *msg);
};

void console_log(const char *msg)
{
    printf("%s\n", msg);
}

int main(void)
{
    struct Logger logger;
    strcpy(logger.name, "console");
    logger.log = console_log;
    logger.log("hello from c struct");
    return 0;
}

这段代码在C语言里是合法的。“log”字段存的是一个函数指针，调用的时候看起来很像C++里的“对象调方法”。但本质完全不同：C的struct仍然只是数据集合，函数本身没有被绑定到struct上，你只是把一个函数的地址当作数据存了下来。

如果你做过嵌入式开发，应该对下面这种用法很熟悉：

c复制typedef struct {
    volatile uint32_t CR;
    volatile uint32_t SR;
    volatile uint32_t DR;
} UART_Regs;

#define UART0 ((UART_Regs *)0x40004000UL)

把struct定义成和设备寄存器地址一一对应的布局，然后用指针对固定地址做读写，就能操作外设。这种“数据即布局，指针即地址”的思维，是C语言的核心功底，也是面试中能加分的回答素材。

2.2 函数指针模拟面向对象：能用，但要掂量代价

在C语言里想模拟类似C++的“多态”，常用套路是给结构体塞一组函数指针。比如Linux内核里的文件操作结构体file_operations，本质上就是这种设计：

c复制struct file_operations {
    ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);
    ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *);
    int (*open)(struct inode *, struct file *);
    int (*release)(struct inode *, struct file *);
};

这样不同的设备驱动可以各自实现read、write、open等回调函数，通过同一个结构体接口对外提供服务。这是C语言实现“面向对象风格”的经典手段。

但代价也很明显：每个对象都要额外保存函数指针，内存占用增加；调用发生间接跳转，难以内联优化；而且没有编译期的访问控制和继承检查，全靠工程师自觉。

C++中如果定义一个不含虚函数的class，成员函数是编译器直接映射成普通函数调用的，对象里根本不需要保存函数指针。这一点如果你在面试中能对比出来，会显得很有经验。

2.3 C程序员绕不开的字节对齐计算

C语言里考察struct，很难绕开sizeof计算。面试官会拿下面这类结构体考你：

c复制struct A {
    char a;
    int  b;
    char c;
};

struct B {
    char a;
    char c;
    int  b;
};

请问sizeof(struct A)和sizeof(struct B)分别是多少？如果按成员字节数简单相加，两个都应该是6，但实际在常见的x86-64 Linux + GCC环境中，结果通常是12和8。

原因就是字节对齐。编译器会在成员之间插入padding，让每个成员都能放到合适的地址上，通常要求：

• char可以出现在任意地址；
• int尽量按4字节对齐摆放；
• 结构体整体大小需要是最大对齐成员的整数倍，这样数组里每个元素的首地址才能都对齐。

struct A的布局是：char a占0号字节，int b不能从1号开始，因为1不是4的倍数，所以中间补3个padding字节，int b从4号字节开始占4个字节，char c放在8号字节，结构体总大小要为4的整数倍，于是在尾部再补3个padding字节，最终得到12。

struct B把两个char放前面，int b直接放在4号位置，布局更紧凑，总大小8。

这个例子在面试中出现频率极高，因为从中能看出你是否了解结构体布局和内存对齐的实际影响。很多人直到遇到线上结构体缓存行横跳、跨进程通信结构体大小对不上，才意识到这块内容有多重要。

如果你用C语言做项目，我还建议你记住一个经验：结构体成员尽量按从大到小排列，或者把同类型成员相邻放置，通常能减少padding浪费。这不是语法要求，但工程收益非常直接。

3. struct从C到C++之后，能力发生了哪些本质变化

3.1 它可以有构造函数、重载、继承，甚至多态

C++在设计时没有把struct删掉，而是做了一个很巧妙的事：让struct在C++里也变成一种“类”。区别仅在于默认访问权限。

所以你在C++中完全可以写出这样的struct：

cpp复制struct Vector3 {
    float x;
    float y;
    float z;

    Vector3(float x = 0.0f, float y = 0.0f, float z = 0.0f)
        : x(x), y(y), z(z) {}

    Vector3 operator+(const Vector3 &rhs) const {
        return Vector3(x + rhs.x, y + rhs.y, z + rhs.z);
    }
};

这段代码在C++中合法，而且Vector3的数据成员默认public，构造函数、运算符重载都能正常工作。你甚至可以定义带虚函数的struct：

cpp复制struct Shape {
    virtual ~Shape() = default;
    virtual double area() const = 0;
};

struct Circle : Shape {
    double r;

    explicit Circle(double r) : r(r) {}

    double area() const override {
        return 3.14159265358979323846 * r * r;
    }
};

Circle是struct，公有继承Shape，Shape里的虚函数area被override。到这里你会发现，C++的struct在语法能力上和class已经没什么差距了。

3.2 成员函数不占对象空间，背后的this机制很关键

面试官如果想要进一步确认你有没有真正理解“类”，通常会问：struct里加了那么多成员函数，sizeof会不会变大？

答案是：不会。

因为成员函数本质上没有被存储在对象内部。编译器会把成员函数编译成类似普通全局函数的形式，再通过一个隐藏参数this把对象地址传进去。

看到obj.func(1, 2)时，编译器内心把它翻译成类似这样的调用：

cpp复制func(&obj, 1, 2);

对象内部只保存数据成员，以及在某些情况下会用到的虚表指针vptr。函数代码放在代码段里，所有对象共享同一份实现。正因为有这个机制，无虚函数的类对象大小，通常就等于数据成员大小加上对齐padding。

这一点和C语言用函数指针模拟方法有明显的区别：C语言里如果每个对象都带一份函数指针数组，那每个对象都会多出指针大小的内存；而C++的成员函数机制不产生这种额外空间开销。理解了this，你就理解了“为什么成员函数不占对象空间”“为什么this指针不能自增自减赋值”“为什么static成员函数没有this”这一连串知识点。

3.3 为什么C++还要再造一个class关键字

有一个很自然的追问：既然C++的struct能干的活和class几乎一样，当年为什么还要引入class？

我的理解是：除了语义表达，更关键的是“默认访问权限”上的安全设计。

struct从C语言继承而来，传统C程序员对struct的预期就是成员全是公开的、随时可以访问赋值，它是一个被动的数据打包容器。如果把这种默认行为直接变成所谓的“默认私有”，会破坏大量已有C代码向C++迁移的兼容性。

而class是C++面向对象新思想的载体。面向对象强调封装，希望把内部数据保护起来，默认私有比默认公开更安全，至少可以减少无意识的越权访问。

所以语言设计者最终选择了“同一种东西，两种默认值”的路线：struct保留C的默认公开风格，让旧时代代码平滑过渡；class默认私有，鼓励你用封装和接口思维设计类型。

4. C++中struct与class的真正差别：两个默认值

4.1 默认访问级别：public与private

C++标准层面，struct和class的直接差异其实只有两处：默认成员访问权限和默认继承方向。

默认成员访问权限是最常挂在嘴边的区别：

cpp复制struct S {
    int a;   // 默认public
};

class C {
    int b;   // 默认private
};

这里的含义是：S可以毫无障碍地用S s; s.a = 1;访问a，而C的b在未加public修饰前，外部无法直接访问。

但要注意，这条规则指的是“默认值”，不是“struct不能私有，class不能公开”。你在struct里明确写private照样可以：

cpp复制struct S {
private:
    int secret;
public:
    void setSecret(int v) {
        secret = v;
    }
};

反过来，class里也可以全部公开。所以面试时如果只说“struct是public的，class是private的”，并不算说错，但不够准确。更严谨的说法是：struct的访问级别默认是public，class默认是private，两者都能通过访问说明符显式控制。

4.2 默认继承方式：public与private继承背后的设计取舍

继承规则是很多人容易忽视的第二点：

cpp复制struct A {};
struct B : A {};  // 默认是 public 继承

class C {};
class D : C {};   // 默认是 private 继承

struct的默认继承是public，这样派生类从语义上仍然是基类的“一种”，is-a关系不会被破坏。class的默认继承是private，更像是一种“实现复用”而非“接口继承”的保守默认。

工程上我不建议任何人依赖这个默认值写继承。明确写出继承方式才是好习惯：

cpp复制struct B : public A {};
class D : public C {};

因为默认规则是给别人看的，而项目代码里的意图必须自己写明。面试时如果你能把这个使用习惯说出来，会让面试官觉得你有实际项目经验，而不是只背了参考手册。

4.3 语言上几乎相同，面试时为什么不能只说“相同”

C++标准里有一句很多人可能听过：如果忽略默认访问权限和默认继承权限，struct和class可以完全互换。

比如下面这两个类型，除了名字不同，外部行为几乎一样：

cpp复制struct S {
private:
    int x;
public:
    S(int v) : x(v) {}
    int get() const { return x; }
};

class C {
private:
    int x;
public:
    C(int v) : x(v) {}
    int get() const { return x; }
};

如果面试官问“那它俩是不是本质上完全一样”，你如果顺着说“对，完全一样”，也容易失分。因为“语言规则一样”和“工程表达习惯一样”是两码事。在真实的C++项目里，struct和class承载了不同的社区约定：struct通常用来表达“数据聚合”，class通常用来表达“带行为、有封装要求的对象”。这个约定虽然没有写入标准，但在代码可读性和团队协作中非常重要。

5. “C struct、C++ struct、C++ class”一张对照表理清三者边界

5.1 关键能力对比

很多同学容易把三个概念搅成一锅粥，我直接做了一张对照表，面试前扫一眼能快速拉通记忆：

这张表回答的是“它们分别是什么”的问题。真正面试时，你要善于把表格里的信息转化成自己的语言流程：先说C语言里struct的原始定位，再说C++里struct被扩展，最后说class与C++结构体的默认值差异以及工程习惯差异。

5.2 工程上应该怎么选，才符合行业习惯

面试官问工程选择，其实是在考察你有没有写过规模稍大的项目。这里我把自己常用的选择标准分享出来：

• 数据本身是核心，公开字段没有复杂不变量，选struct；
• 类型里带私有状态、需要维护约束条件、生命周期或资源管理的，选class；
• 和C代码跨语言交互、需要保证二进制布局稳定的，优先考虑struct，并尽量让它保持平凡可复制；
• 需要表达抽象接口或类层次时，无论用struct还是class，都建议显式写明继承访问级别。

一个比较有代表性的设计例子：

cpp复制struct Point {
    int x;
    int y;
};

class Rectangle {
public:
    Rectangle(Point leftTop, Point rightBottom)
        : leftTop_(leftTop), rightBottom_(rightBottom) {}

    bool contains(const Point &p) const;

private:
    Point leftTop_;
    Point rightBottom_;
};

Point只是“两个整数组合成一个坐标”的数据聚合，所以用struct很自然；Rectangle对外提供几何判断能力，内部成员需要受到约束控制，所以用class。这个设计几乎不需要额外注释，读代码的人一看就能明白作者的意图。

如果有人说“我统一用class加public也能实现Point”，从语法角度没错，但工程阅读体验完全不同。struct关键字本身就在向读者传达“这个类型是轻量数据载体”。

6. struct/class的面试连环追问：命中率很高的变体题

6.1 sizeof为什么不是成员大小之和

面试官问完基础区别后，经常立刻掏出一道sizeof题，因为这是防止候选人“背概念”的有效手段。最经典的还是前面提过的：

cpp复制struct A { char a; int b; char c; };
struct B { char a; char c; int b; };

在64位Linux + GCC环境实测，sizeof(A)通常是12，sizeof(B)通常是8。这个题考察的不只是算数，而是你是否了解padding补齐的规则：

• 每个成员按自身对齐值偏移；
• 结构体总大小按最大对齐成员对齐；
• struct A尾部多出来的padding是为了数组连续性。

面试回答时建议顺带补一句：“不同平台和不同编译选项下结果可能有差异，可以用offsetof宏验证每个成员的偏移。”这句话会把“背答案的人”和“在工程里真正研究过内存布局的人”区分开。

6.2 空struct/空class：为什么不能让大小为0

在C++中定义一个空类型：

cpp复制struct Empty {};
class EmptyClass {};

这两个类型的大小通常都是1，而不是0。

原因很简单：C++要求同一个类型的多个不同对象必须拥有不同地址。如果空类型大小是0，那么数组里连续两个空对象就会占据同一个地址，这会破坏指针唯一性的基本原则。所以标准规定，完整对象的大小最小为1。

但是C语言里，空结构体并不是标准支持的特性。部分编译器作为扩展允许空结构体存在，甚至可能让大小为0。这一点偶尔会被面试官拿出来和C++对比，主要看你对两个语言标准的了解程度。

讲到空类，还有一个加分进阶点：空基类优化。如果一个空类型作为基类，派生类可以复用基类占用的那1个字节，不再额外为其分配空间，这叫EBO。典型例子：

cpp复制struct Empty {};
struct Derived : Empty {
    int x;
};

在开启空基类优化的编译器上，sizeof(Derived)往往就是4，而不是8。STL里很多空类型作为基类出现，就是为了利用这个优化消除不必要的内存开销。

6.3 一问到虚函数，内存布局完全改变

如果面试官继续问：“含有虚函数的struct和没有虚函数的struct，内存布局有什么不同？”你要能说出：带虚函数的类/结构体通常会在对象开头插入一个vptr指针，指向这个类型对应的虚函数表。

伪代码理解：

cpp复制struct Base {
    virtual void foo(); // 对象里隐藏了一个 vptr
};

在实际编译产物中，对象模型大概相当于：

cpp复制struct Base {
    void **vptr;
    // 其他数据成员
};

因为这个vptr的存在，原本一个只有int成员的空虚类类型，在64位环境下大小可能变成16字节（int本身4字节加padding到指针对齐的8字节，vptr再占8字节，最后是16），而不是纯数据成员的8字节。

这个知识点经常和“C++中struct和class到底差在哪”结合考。因为一旦引入虚函数，无论关键字是struct还是class，内存布局都会遵循同一套C++对象模型规则。这也是强调“struct和class语言规则几乎一致”的最好例子。

6.4 C与C++互操作时怎么设计才能不被卡住

如果岗位涉及混合编译，面试官还喜欢问：一段数据要同时被C和C++调用，应该怎么设计。

最稳妥的方案是：把跨语言边界的类型定义成一个在两边都表现一致的struct，并且让它保持“平凡可复制”（TriviallyCopyable）。不要让这个struct拥有虚函数、自定义析构函数、引用成员等复杂特性，否则C语言那边无法正确构造和销毁这份数据。

可以参考这种做法：

cpp复制// C++侧
extern "C" {
struct Config {
    int width;
    int height;
};

void set_config(const Config *cfg);
}

而在C侧，用同样布局的struct接收。双方看到的都是一段连续内存：两个int。C++侧不允许把带虚函数、带特殊成员函数的类型直接通过C API边界传递，因为C编译器根本不知道拷贝构造、析构、vptr这些概念的存在。

这点我建议所有准备跨平台或做SDK的同学认真记一记，实际项目里因为共享内存、BUFF传输时结构体布局不一致导致的线上bug，真的不少。

最后分享一个我个人的复习习惯：我不建议死背“struct默认public、class默认private”就收工。写完这道题，你一定要能动手实现一个“用C函数指针模拟类”的小demo，再把这个demo改成C++的struct版本，观察两者内存和使用体验上的差异，最后再把同样的类改成class并尝试封装。这三步走下来，所获得的感受远比背一百条八股文深刻。面试当中被问到这套题时，只要你能从C的底层布局讲到C++的对象模型再讲到工程习惯，面试官基本就会认为你真正理解了，而不是临时背答案。