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++中，当类被实例化为对象时，只有成员变量会被存储在对象中，而成员函数不会。成员函数是存储在代码段中的一段指令，所有对象共享同一份函数指令。因此，无论类有多少个对象，成员函数只会存在一份。
示例：
class Date {
public:
void Init(int year, int month, int day);
private:
int _year;
int _month;
int _day;
};
3. this 指针
3.1 什么是 this 指针
this 是C++中的一个隐式指针，存在于每一个非静态成员函数中。this 指针指向调用该成员函数的当前对象。在类的成员函数中，this 指针可以用来访问类的成员变量和成员函数。
- 当我们在成员函数中使用类的成员变量时，本质上是通过
this指针访问该成员变量。 this指针是隐含的，C++自动将它传递给所有非静态成员函数。
this 指针的内部机制
在C++中，当类的成员函数被调用时，this 指针会被自动传递给该函数。this 指针的类型是 const Type* const，它是一个只读指针，指向当前对象。你不能修改 this 指针的值，但可以通过 this 访问对象的成员。
3.2 示例代码
#include<iostream>
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。
好的，我会在 this 指针部分补充所有的测试内容，并在该部分加入关于 命名 的内容，确保详细且连贯。以下是需要补充的内容：
3.3 this指针的测试题
测试题 1：this 指针的基本行为
#include<iostream>
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. 正常运行
测试题 2：this 指针与成员变量的访问
#include<iostream>
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 为 nullptr，没有有效的内存空间可供访问。
测试题 3：this 指针的存储位置
选择题：this 指针存在于内存的哪个区域？
- A. 栈
- B. 堆
- C. 静态区
- D. 常量区
- E. 对象里
正确答案：A. 栈
解释：
this 指针作为成员函数的一个隐含参数，存储在栈中。每当一个成员函数被调用时，this 指针会作为函数参数被压入栈中。
4. C++和C语言实现Stack的对比
通过C和C++语言实现 Stack 栈的对比，展现了C++相较于C语言在封装和安全性方面的优势。
4.1 C语言实现Stack
在C语言中，实现 Stack 需要使用 struct 来定义栈的数据结构，并且所有的栈操作（如初始化、压栈、弹栈等）都通过独立的函数实现。由于C语言不支持面向对象编程，数据和操作必须分开处理，所有栈操作的函数需要手动传递 Stack 结构体的指针作为参数。
C语言实现Stack的代码示例
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
typedef 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的代码示例
#include<iostream>
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的访问效率。
5.1 内存对齐规则
内存对齐规则规定：
-
第一个成员存储在偏移量为0的地址处。
-
其他成员必须存储在某个对齐数的整数倍的地址处。
-
对齐数取决于编译器的设置和变量的类型，通常为4字节或8字节。
5.2 示例代码
#include<iostream>
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 内存对齐的影响
内存对齐会影响类的实际大小。例如，以下代码展示了不同对齐方式下对象的大小变化：
#include<iostream>
#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字节，没有插入额外的填充字节。
![学会这几个简单的bat代码，轻松在朋友面前装一波13[通俗易懂]](https://img-blog.csdnimg.cn/img_convert/e13e05bda6fb92463efbc95057a3e587.jpeg)
