美容院网站源码,天猫网站平面广告,怎么下载有风险的软件,爆款采集推广引流软件文章目录 C 类与对象——详细入门指南前言1. 类的定义1.1 类定义的基本格式示例代码解释 1.2 访问限定符示例代码解释 1.3 类域示例代码解释 1.4 成员命名规范常见的命名约定#xff1a;示例#xff1a;拓展#xff1a; 1.5 class与struct的默认访问权限示例#xff1a; 2.… 文章目录 C 类与对象——详细入门指南前言1. 类的定义1.1 类定义的基本格式示例代码解释 1.2 访问限定符示例代码解释 1.3 类域示例代码解释 1.4 成员命名规范常见的命名约定示例拓展 1.5 class与struct的默认访问权限示例 2. 类的实例化2.1 实例化概念示例代码解释 2.2 对象的大小与存储示例代码解释 2.3 对象大小空类的情况空类对象的大小为什么空类对象占1字节 示例代码空类的对象大小输出结果解释 拓展含有静态成员的类结论 3. this 指针3.1 什么是 this 指针this 指针的内部机制 3.2 示例代码解释拓展解释this指针使用的情况 3.3 this指针的测试题测试题 1this 指针的基本行为问题描述解析正确答案C. 正常运行 测试题 2this 指针与成员变量的访问问题描述解析正确答案B. 运行时崩溃 详细解释为什么不是空指针访问测试题 3this 指针的存储位置 4. C和C语言实现Stack的对比4.1 C语言实现StackC语言实现Stack的代码示例C语言实现Stack的详细解释 4.2 C语言实现StackC实现Stack的代码示例C实现Stack的详细解释拓展解释构造函数和析构函数 4.3 C和C语言实现Stack的对比总结 5. 内存对齐5.1 内存对齐规则5.2 示例代码解释拓展解释为什么需要内存对齐 5.3 内存对齐的影响解释 写在最后 C 类与对象——详细入门指南
前言 欢迎讨论如果你在学习过程中有任何问题或想法欢迎在评论区留言我们一起交流学习。你的支持是我继续创作的动力 点赞、收藏与分享觉得这篇文章对你有帮助吗别忘了点赞、收藏并分享给更多的小伙伴哦你们的支持是我不断进步的动力 分享给更多人如果你觉得这篇文章对你有帮助欢迎分享给更多对C感兴趣的朋友让我们一起进步 1. 类的定义
在C中类是面向对象编程的基础概念之一。类通过将数据和行为封装在一起模拟现实世界中的实体。通过类我们可以定义对象的属性成员变量和行为成员函数。
1.1 类定义的基本格式
类的定义使用 class 关键字后面跟上类的名称。在C中类体需要用大括号 {} 包裹并在类定义结束时加上分号 ;。类中的内容称为类的成员包括
成员变量即类的属性存储类的状态。成员函数即类的方法定义类的行为。
示例代码
#include iostream
using namespace std;class Stack {
public:// 成员函数初始化栈void Init(int n 4) {array (int*)malloc(sizeof(int) * n);if (nullptr array) {perror(malloc申请空间失败);return;}capacity n;top 0;}// 成员函数将元素推入栈void Push(int x) {// 如果栈满进行扩容array[top] x;}// 成员函数获取栈顶元素int Top() {assert(top 0);return array[top - 1];}// 成员函数销毁栈void Destroy() {free(array);array nullptr;top capacity 0;}private:// 成员变量栈的实现细节int* array;size_t capacity;size_t top;
};int main() {Stack st;st.Init();st.Push(1);st.Push(2);cout st.Top() endl;st.Destroy();return 0;
}解释
class定义类的关键字。Stack类的名称。成员函数例如 Init、Push、Top 和 Destroy它们定义了类的行为。成员变量例如 array、capacity、top这些变量存储类的状态或属性。public/private访问限定符决定了类的成员是如何被访问的。public 成员可以在类外访问private 成员则只能在类内部使用。
1.2 访问限定符
访问限定符是C实现封装的方式之一它决定了类的成员能否被类外部的用户访问。
public修饰的成员可以在类外部直接访问。private修饰的成员只能在类内部访问类外不能直接访问。protected类似于 private但在继承中子类可以访问 protected 成员。之后会详细讲解 访问权限作⽤域从该访问限定符出现的位置开始直到下⼀个访问限定符出现时为⽌如果后⾯没有访问限定符作⽤域就到 }即类结束。 示例代码
class Date {
public:// 公有成员函数void Init(int year, int month, int day) {_year year;_month month;_day day;}private:// 私有成员变量int _year;int _month;int _day;
};int main() {Date d;d.Init(2024, 3, 31);return 0;
}解释
public声明的 Init 函数是公共的可以在类外部使用。private_year、_month 和 _day 是私有成员不能在类外部直接访问只有类的成员函数能访问这些变量。
1.3 类域
类的作用域决定了类成员的可访问性。在类外定义成员函数时需要通过作用域解析符 :: 指明成员属于哪个类。例如如果在类外定义成员函数需要使用类名和作用域解析符。
示例代码
#include iostream
using namespace std;class Stack {
public:void Init(int n 4);
private:int* array;size_t capacity;size_t top;
};// 使用作用域解析符在类外定义成员函数
void Stack::Init(int n) {array (int*)malloc(sizeof(int) * n);if (nullptr array) {perror(malloc申请空间失败);return;}capacity n;top 0;
}int main() {Stack st;st.Init();return 0;
}解释
Stack::Init:: 作用域解析符表示 Init 函数属于 Stack 类。通过作用域解析符编译器可以知道该函数属于哪个类并可以在类的作用域中查找成员变量 array、capacity 和 top。
1.4 成员命名规范
在C中通常会为类的成员变量使用特定的命名约定以避免与函数参数或局部变量混淆。这些命名约定可以提高代码的可读性和维护性。
常见的命名约定
使用下划线 _在成员变量的名称前加一个下划线以区分成员变量和其他变量。使用 m_ 前缀成员变量以 m_ 开头表示 “member”成员变量。驼峰命名法使用驼峰命名法例如 myVariable使得代码更易读。
示例
class Date {
private:int _year; // 使用下划线前缀int m_month; // 使用 m_ 前缀int dayOfMonth; // 使用驼峰命名法
public:void SetDate(int year, int month, int day) {_year year;m_month month;dayOfMonth day;}
};拓展
这种命名约定并不是C语言的强制要求而是遵循公司或团队的编码风格指南。使用这些命名约定可以避免命名冲突并让代码的意图更加明确。例如在 SetDate 函数中使用 _year 和 year 可以轻松区分成员变量和函数参数减少混淆。
1.5 class与struct的默认访问权限
在C中class 和 struct 的区别主要在于默认的访问权限
在 class 中未标明的成员变量和成员函数默认是 private。在 struct 中未标明的成员变量和成员函数默认是 public。
示例
struct ExampleStruct {int a; // 默认 public
};class ExampleClass {int b; // 默认 private
};2. 类的实例化
2.1 实例化概念
实例化是指在物理内存中创建对象的过程。类是对象的抽象描述它提供了对象的结构和行为但是类本身并不占用物理空间只有当类被实例化时才会在内存中分配空间。 示例代码
#include iostream
using namespace std;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;d1.Init(2024, 3, 31);d1.Print();Date d2;d2.Init(2024, 7, 5);d2.Print();return 0;
}解释
Date d1实例化一个 Date 对象 d1。Init调用 Init 函数初始化 d1 对象的成员变量 _year、_month 和 _day。Print输出对象的日期信息。
2.2 对象的大小与存储
当类被实例化为对象时对象的大小取决于类的成员变量。成员变量需要分配空间但成员函数不会在对象中存储。成员函数是存储在单独的代码段中的一段指令。 示例代码
#include iostream
using namespace std;class A {
private:char _ch; // 1 字节int _i; // 4 字节
};int main() {A a;cout sizeof(a) endl; // 输出对象的大小return 0;
}解释
该类的成员变量 _ch 和 _i 总共占用 5 字节但由于内存对齐实际对象的大小可能是 8 字节。内存对齐规则保证了访问效率见下文解释。
2.3 对象大小空类的情况
在C中对象的大小是由类的成员变量决定的而类的成员函数不会影响对象的大小。因此如果一个类没有任何成员变量而只有成员函数我们称之为空类。这种空类的对象大小在C中也是有规定的。
空类对象的大小 尽管空类没有成员变量但在C中空类的对象大小仍然不是零。空类的对象大小是1字节。这是因为C规定每个类的对象都必须占有唯一的地址即使类中没有成员变量。这1字节的大小用于确保不同的对象在内存中拥有唯一的地址。 为什么空类对象占1字节
即使类中没有任何成员变量C仍然需要给这个对象分配空间以便它在内存中有一个唯一的地址。这样做有几个目的 区分不同对象的地址如果类对象占据0字节那么多个对象可能会共享同一个内存地址这会导致无法区分不同的对象。因此C规定空类对象至少占用1字节的空间。 确保类的指针行为一致即使是空类的指针指向不同对象时它们也必须指向不同的内存地址。如果空类对象占0字节就无法保证这一点。
示例代码空类的对象大小
#includeiostream
using namespace std;class EmptyClass {
public:void Print() {cout This is an empty class! endl;}
};int main() {EmptyClass e1, e2;cout EmptyClass 对象 e1 的大小: sizeof(e1) 字节 endl;cout EmptyClass 对象 e2 的大小: sizeof(e2) 字节 endl;return 0;
}输出结果
EmptyClass 对象 e1 的大小: 1 字节
EmptyClass 对象 e2 的大小: 1 字节解释
尽管 EmptyClass 中没有任何成员变量但每个对象 e1 和 e2 仍然占用 1 字节。这是为了保证每个对象都有唯一的内存地址C通过分配1字节来实现这一点。
拓展含有静态成员的类 如果一个类只包含静态成员函数或静态成员变量该类的对象大小依然是1字节。原因是静态成员属于整个类而不是某个具体的对象因此静态成员无论是函数还是变量不会影响对象的大小。 示例代码含有静态成员函数和静态成员变量的类
#includeiostream
using namespace std;class StaticClass {
public:static void StaticPrint() {cout This is a static function! endl;}static int staticVar; // 静态成员变量
};// 定义并初始化静态成员变量
int StaticClass::staticVar 10;int main() {StaticClass s1;StaticClass s2;cout StaticClass 对象 s1 的大小: sizeof(s1) 字节 endl;cout StaticClass 对象 s2 的大小: sizeof(s2) 字节 endl;// 修改静态成员变量s1.staticVar 20;cout s1.staticVar: s1.staticVar endl;cout s2.staticVar: s2.staticVar endl;return 0;
}输出结果
StaticClass 对象 s1 的大小: 1 字节
StaticClass 对象 s2 的大小: 1 字节
s1.staticVar: 20
s2.staticVar: 20解释
静态成员函数和静态成员变量都属于类而不是对象。因此类 StaticClass 中的静态成员函数 StaticPrint 和静态成员变量 staticVar 都不影响对象的大小。 对象 s1 和 s2 的大小依然为 1 字节静态成员变量在类的所有对象中共享只占用一份内存。
结论
空类对象的大小是1字节即使类中没有成员变量C仍然会为每个空类对象分配1字节的空间以确保每个对象有唯一的内存地址。静态成员不影响对象的大小因为它们属于类而不是对象空类或仅含有静态成员函数或者变量的类对象同样占用1字节。 3. this 指针
3.1 什么是 this 指针 this 是C中的一个隐式指针存在于每一个非静态成员函数中。this 指针指向调用该成员函数的当前对象。在类的成员函数中this 指针可以用来访问类的成员变量和成员函数。 当我们在成员函数中使用类的成员变量时本质上是通过 this 指针访问该成员变量。this 指针是隐含的C自动将它传递给所有非静态成员函数。
this 指针的内部机制
在C中当类的成员函数被调用时this 指针会被自动传递给该函数。this 指针的类型是 const Type* const它是一个只读指针指向当前对象。你不能修改 this 指针的值但可以通过 this 访问对象的成员。
3.2 示例代码
#includeiostream
using namespace std;class Date {
public:void Init(int year, int month, int day) {this-_year year; // 通过 this 指针访问成员变量this-_month month;this-_day day;}void Print() {cout _year / _month / _day endl;}private:int _year;int _month;int _day;
};int main() {Date d1;d1.Init(2024, 3, 31);d1.Print();return 0;
}解释
this在 Init 函数中this-_year year 表示将传入的参数 year 赋值给当前对象的 _year 成员变量。this 指针指向当前调用 Init 函数的对象即 d1。
拓展解释this指针使用的情况
在通常的情况下编写代码时我们不需要显式使用 this 指针因为C会自动处理类的成员和参数之间的冲突。但是在某些情况下例如当函数的参数名称和成员变量名称相同时使用 this 指针可以明确地表示成员变量。
void Init(int year, int month, int day) {this-year year; // 通过 this 指针区分成员变量和函数参数this-month month;this-day day;
}在上面的代码中如果不使用 this编译器会把 year 解释为函数参数而不是成员变量 的year。这就导致了未定义的行为成员变量没有被正确的赋值。 所以也进一步说明了我们在类里面定义的成员变量需要有一种命名规范笔者习惯用_作为前缀 3.3 this指针的测试题
测试题 1this 指针的基本行为
#includeiostream
using namespace std;class A {
public:void Print() {cout A::Print() endl;}
private:int _a;
};int main() {A* p nullptr;p-Print(); // 能否正常运行return 0;
}问题描述
我们定义了一个 A 类包含一个成员函数 Print()它只是输出一条字符串。我们通过空指针 p 调用 Print() 函数询问这段代码能否正常运行。
解析
在 main() 函数中A* p nullptr; 创建了一个指向 A 类的空指针 p。随后我们通过空指针 p-Print() 来调用成员函数 Print()这里的 this 指针其实是空指针。
为什么不会报错
当我们调用 p-Print() 时this 指针实际上等于 nullptr但由于 Print() 函数没有访问任何成员变量因此C允许这个调用。this 指针是隐含的虽然在函数内部会传递 this但是如果成员函数不访问任何成员变量C不需要解引用这个空指针因此不会出现空指针访问的错误。Print() 函数只是输出了一段固定的文本不涉及对象的状态或成员变量因此即使 this 是空指针也不会导致问题。
正确答案C. 正常运行 测试题 2this 指针与成员变量的访问
#includeiostream
using namespace std;class A {
public:void Print() {cout A::Print() endl;cout _a endl;}
private:int _a;
};int main() {A* p nullptr;p-Print(); // 能否正常运行return 0;
}问题描述
这段代码和前一个问题类似但在 Print() 函数中多了一个成员变量 _a 的访问。通过空指针 p 调用 Print()是否会出现空指针访问的问题
解析
在 main() 中和之前一样A* p nullptr; 创建了一个指向 A 类的空指针 p。当调用 p-Print() 时this 指针仍然是 nullptr。
为什么会崩溃
在 Print() 函数中除了输出 A::Print() 以外代码还试图访问类的成员变量 _a。当 this 指针为 nullptr 时访问 this-_a 等同于尝试通过空指针访问成员变量。这是一种未定义行为在大多数系统中会导致程序崩溃。成员变量 _a 存储在对象的内存空间中而通过空指针访问成员变量时由于没有实际的对象空间可用因此程序在运行时会发生崩溃。
正确答案B. 运行时崩溃 详细解释为什么不是空指针访问
在这两个测试题中关键点在于是否访问了成员变量 测试题 1 中Print() 函数没有访问成员变量所以即使 this 是空指针C也不会触发空指针访问错误。这是因为成员函数本质上只是一个在内存中的函数指针调用它并不一定需要访问实际对象的内存。 测试题 2 中Print() 函数试图访问成员变量 _a。由于成员变量存储在对象的内存空间中而空指针 this 并没有指向有效的内存区域所以在运行时会试图通过空指针访问内存导致程序崩溃。这是典型的空指针访问错误。 总结来说空指针调用成员函数本身并不会报错因为成员函数本来就不在类中所以不是解引用编译时的汇编代码这里就只是一段函数的地址而已只是这里没有对象传过去的this指针就是空指针但只要该成员函数不涉及访问成员变量或其他依赖对象内存的操作那就不会报错。然而一旦成员函数试图通过 this 指针访问成员变量程序就会崩溃因为 this 为 nullptr没有有效的内存空间可供访问。 测试题 3this 指针的存储位置
选择题this 指针存在于内存的哪个区域
A. 栈B. 堆C. 静态区D. 常量区E. 对象里
正确答案A. 栈
解释 this 指针作为成员函数的一个隐含参数存储在栈中。每当一个成员函数被调用时this 指针会作为函数参数被压入栈中。 this指针其实就是函数的参数而已 4. C和C语言实现Stack的对比
接下来我们通过C和C语言实现 Stack 栈的对比展现C相较于C语言在封装和安全性方面的优势。
4.1 C语言实现Stack
在C语言中实现 Stack 需要使用 struct 来定义栈的数据结构并且所有的栈操作如初始化、压栈、弹栈等都通过独立的函数实现。由于C语言不支持面向对象编程数据和操作必须分开处理所有栈操作的函数需要手动传递 Stack 结构体的指针作为参数。
C语言实现Stack的代码示例
#includestdio.h
#includestdlib.h
#includestdbool.h
#includeassert.htypedef int STDataType;
typedef struct Stack {STDataType* array;int top;int capacity;
} Stack;void Init(Stack* s) {s-array (STDataType*)malloc(4 * sizeof(STDataType));s-capacity 4;s-top 0;
}void Destroy(Stack* s) {free(s-array);s-array NULL;s-top 0;s-capacity 0;
}void Push(Stack* s, STDataType x) {if (s-top s-capacity) {s-capacity * 2;s-array (STDataType*)realloc(s-array, s-capacity * sizeof(STDataType));}s-array[s-top] x;
}STDataType Top(Stack* s) {assert(s-top 0);return s-array[s-top - 1];
}void Pop(Stack* s) {assert(s-top 0);--s-top;
}bool Empty(Stack* s) {return s-top 0;
}int main() {Stack s;Init(s);Push(s, 1);Push(s, 2);printf(栈顶元素: %d\n, Top(s));Pop(s);printf(栈顶元素: %d\n, Top(s));Destroy(s);return 0;
}C语言实现Stack的详细解释 结构体Stack这是一个结构体包含了三个成员 array一个指向栈的动态数组的指针用来存储栈中的元素。top指向栈顶元素的指针它代表当前栈中元素的个数。capacity栈的容量表示栈中最多可以容纳的元素个数。 函数Init用于初始化栈的大小并为数组分配内存。C语言中没有构造函数因此必须通过函数显式初始化结构体。 函数Push将元素压入栈中如果栈满则进行扩容操作使用 realloc 函数为栈分配更大的内存。 函数Top返回栈顶元素调用时需要确保栈不为空。 函数Pop将栈顶元素弹出减少 top 的值。 内存管理通过 malloc 和 realloc 动态分配内存使用 free 释放内存。 4.2 C语言实现Stack
C通过类的封装可以将数据和操作放在一起。栈的实现不仅更为简洁而且通过封装性提高了代码的安全性和可维护性。相比C语言C不需要手动传递 Stack 指针而是通过类的成员函数自动操作栈。
C实现Stack的代码示例
#includeiostream
using namespace std;class Stack {
public:Stack(int n 4) {_array (int*)malloc(sizeof(int) * n);_capacity n;_top 0;}~Stack() {free(_array);_array nullptr;}void Push(int x) {if (_top _capacity) {_capacity * 2;_array (int*)realloc(_array, _capacity * sizeof(int));}_array[_top] x;}int Top() {assert(_top 0);return _array[_top - 1];}void Pop() {assert(_top 0);--_top;}bool Empty() {return _top 0;}private:int* _array;size_t _capacity;size_t _top;
};int main() {Stack s;s.Push(1);s.Push(2);cout 栈顶元素: s.Top() endl;s.Pop();cout 栈顶元素: s.Top() endl;return 0;
}C实现Stack的详细解释 构造函数和析构函数 构造函数 Stack(int n 4)用于初始化栈分配内存并设置栈的容量。这里的 n 是栈的初始大小默认值为4。构造函数在对象创建时自动调用确保对象处于有效的状态。析构函数 ~Stack()当栈对象被销毁时自动释放动态分配的内存。这是C相比C语言的一个显著优势因为不需要手动调用 Destroy 函数来释放资源。 成员函数Push与C语言中的 Push 函数类似用于将元素压入栈中。栈满时会自动扩容但通过成员函数的封装这一操作对类外的用户是透明的用户只需要调用 Push 方法即可。 成员函数Top返回栈顶元素和C语言一样操作之前会检查栈是否为空保证操作的安全性。 封装性相比C语言C通过类的 private 成员变量 _array、_capacity 和 _top将栈的实现细节封装起来防止用户直接操作这些数据。所有的操作都通过 public 成员函数完成保证了数据的安全性。
拓展解释构造函数和析构函数
在下一篇博客会详细解释 构造函数它是类中的特殊函数当类的对象被创建时构造函数会被自动调用用于初始化对象。在 Stack 类中构造函数初始化栈的容量并为数组分配内存。 析构函数它也是类中的特殊函数当对象生命周期结束如对象作用域结束时时析构函数会自动调用用于释放对象所占用的资源。在 Stack 类中析构函数用于释放 malloc 分配的内存避免内存泄漏。 4.3 C和C语言实现Stack的对比总结
通过对C和C实现 Stack 的对比可以得出以下几点总结 封装性C通过类的封装将数据和操作整合在一起类的用户不需要关心栈的实现细节而C语言的实现则需要用户手动调用函数并管理结构体的状态。 内存管理C语言中内存管理是手动的开发者必须显式调用 free 函数释放内存。而在C中析构函数自动负责资源的释放避免了忘记释放内存导致的内存泄漏问题。 安全性C中的类通过 private 关键字保护类的内部数据防止外部代码随意修改类的成员变量增强了数据的安全性。而C语言没有这种封装机制所有数据都可以通过结构体直接访问容易导致意外的修改和错误。 5. 内存对齐 内存对齐是计算机系统中用于优化数据访问的机制。在C中类的成员变量在内存中的存放位置要遵循特定的对齐规则以提高CPU的访问效率。 这部分内容在C语言结构体详细介绍过详情请见【C语言篇】结构体和位段详细介绍
5.1 内存对齐规则
内存对齐规则规定 第一个成员存储在偏移量为0的地址处。 其他成员必须存储在某个对齐数的整数倍的地址处。 对齐数取决于编译器的设置和变量的类型通常为4字节或8字节。
5.2 示例代码
#includeiostream
using namespace std;class A {
private:char _ch; // 1 字节int _i; // 4 字节
};int main() {A a;cout 对象 A 的大小: sizeof(a) 字节 endl; // 输出对象大小return 0;
}解释
尽管 A 类中的 _ch 和 _i 变量加起来只有 5 字节但由于内存对齐规则类的实际大小为 8 字节。这是因为 int 变量 _i 要求4字节对齐而 char 只占1字节因此在 char 后面会插入3个字节的填充空间以便 int 对齐到4字节边界。
拓展解释为什么需要内存对齐 内存对齐的意义内存对齐的目的是为了优化CPU的读取速度。在现代计算机架构中处理器一次性读取的内存块大小通常为4字节或8字节。如果数据存储在不对齐的地址上处理器需要执行更多的操作来读取数据从而影响性能。因此通过对齐存储处理器可以更快速地读取和写入数据。 内存对齐和空间浪费虽然内存对齐提高了数据访问的效率但也可能会造成空间浪费。例如在上例中char 类型只需要1字节但为了对齐 int额外浪费了3个字节的填充空间。这种权衡在性能优化和内存空间利用之间找到了平衡。 5.3 内存对齐的影响
内存对齐会影响类的实际大小。例如以下代码展示了不同对齐方式下对象的大小变化
#includeiostream
#pragma pack(1) // 设置内存对齐为1字节
using namespace std;class B {
public:char _ch; // 1字节int _i; // 4字节
};int main() {B b;cout 对象 B 的大小: sizeof(b) 字节 endl; // 输出对象 B 的大小为 5 字节return 0;
}
#pragma pack() // 恢复默认对齐解释
通过使用 #pragma pack(1) 指令我们将类 B 的内存对齐设置为 1 字节对齐。这样char 类型占用 1 字节int 类型占用 4 字节总共5字节没有插入额外的填充字节。 写在最后 在这篇文章中我们深入探讨了C中类与对象的基础概念。我们从类的定义开始讲解了类的封装、成员变量和成员函数的区别与作用介绍了类的访问限定符及其影响。同时我们讨论了对象的实例化及其内存存储机制包括了空类对象的内存占用问题。通过this指针的机制我们了解了C中对象访问成员的内部逻辑。最后我们对比了C和C语言实现Stack的方式并讲解了内存对齐的规则及其影响。希望这些内容能帮助你更好地理解C中的类与对象这一核心概念。 以上就是关于C类与对象深度解析一从抽象到实践的全面入门指南的内容啦各位大佬有什么问题欢迎在评论区指正或者私信我也是可以的啦您的支持是我创作的最大动力❤️
