当前位置：首页 > news >正文

栈/堆/static/虚表

news 来源：原创 2025/8/7 8:58:44

在 C++ 里，栈空间主要用来存放局部变量、函数调用信息等。下面为你介绍栈空间在 C++ 里的运用方式。

1. 局部变量的使用

在函数内部定义的变量会被存于栈空间，当函数执行结束，这些变量会自动被销毁。

#include <iostream>void exampleFunction() {// 定义一个局部变量，存于栈空间int localVar = 10;std::cout << "Local variable value: " << localVar << std::endl;
}int main() {exampleFunction();return 0;
}

2. 函数调用栈

每次调用函数时，系统会在栈上为该函数创建一个栈帧，用来保存函数的局部变量、参数、返回地址等信息。函数返回时，对应的栈帧会被销毁。

#include <iostream>void func2(int value) {std::cout << "Value in func2: " << value << std::endl;
}void func1() {int localVar = 20;func2(localVar);
}int main() {func1();return 0;
}

3. 递归调用

递归函数是在函数内部调用自身，每次递归调用都会在栈上创建新的栈帧。要注意递归深度，防止栈溢出。

#include <iostream>// 递归计算阶乘
int factorial(int n) {if (n == 0 || n == 1) {return 1;}return n * factorial(n - 1);
}int main() {int num = 5;std::cout << "Factorial of " << num << " is: " << factorial(num) << std::endl;return 0;
}

栈空间使用的注意事项

栈溢出：若栈空间使用过多，例如递归过深或者局部变量占用空间过大，就会引发栈溢出错误。
生命周期：栈上的变量生命周期局限于定义它的代码块，出了代码块就会被销毁。

在 C++ 中，堆空间用于动态分配内存，可在程序运行时根据需要分配和释放内存。下面详细介绍堆空间的使用方法。

1. 使用 `new` 和 `delete` 操作符进行内存分配和释放

分配单个对象：使用 new 操作符为单个对象分配内存，使用 delete 操作符释放内存。

#include <iostream>int main() {// 在堆上分配一个 int 类型的对象int* ptr = new int;*ptr = 42;std::cout << "Value: " << *ptr << std::endl;// 释放堆上的内存delete ptr;return 0;
}

分配数组：使用 new[] 操作符为数组分配内存，使用 delete[] 操作符释放内存。

#include <iostream>int main() {// 在堆上分配一个包含 5 个 int 元素的数组int* arr = new int[5];for (int i = 0; i < 5; ++i) {arr[i] = i;}// 输出数组元素for (int i = 0; i < 5; ++i) {std::cout << arr[i] << " ";}std::cout << std::endl;// 释放堆上的数组内存delete[] arr;return 0;
}

2. 使用智能指针管理堆内存

为了避免手动管理内存带来的内存泄漏问题，C++ 提供了智能指针。常用的智能指针有 std::unique_ptr、std::shared_ptr 和 std::weak_ptr。

std::unique_ptr：独占所指向的对象，同一时间只能有一个 std::unique_ptr 指向该对象。

#include <iostream>
#include <memory>int main() {// 使用 std::unique_ptr 管理堆上的 int 对象std::unique_ptr<int> ptr = std::make_unique<int>(42);std::cout << "Value: " << *ptr << std::endl;// 不需要手动释放内存，std::unique_ptr 会在离开作用域时自动释放return 0;
}

std::shared_ptr：多个 std::shared_ptr 可以共享同一个对象，使用引用计数来管理对象的生命周期。

#include <iostream>
#include <memory>int main() {// 使用 std::shared_ptr 管理堆上的 int 对象std::shared_ptr<int> ptr1 = std::make_shared<int>(42);std::shared_ptr<int> ptr2 = ptr1;std::cout << "Value: " << *ptr2 << std::endl;// 当所有指向该对象的 std::shared_ptr 都被销毁时，对象会自动释放return 0;
}

3. 自定义类对象的堆内存管理

在自定义类中，需要注意析构函数的实现，确保在对象销毁时正确释放堆上的内存。

#include <iostream>class MyClass {
private:int* data;
public:MyClass(int value) {// 在构造函数中分配堆内存data = new int(value);}~MyClass() {// 在析构函数中释放堆内存delete data;}int getValue() const {return *data;}
};int main() {MyClass obj(42);std::cout << "Value: " << obj.getValue() << std::endl;return 0;
}

堆空间使用的注意事项

内存泄漏：如果使用 new 分配了内存，但没有使用 delete 或 delete[] 释放，或者智能指针管理不当，会导致内存泄漏。
悬空指针：释放内存后，指针仍然指向原来的内存地址，使用这样的指针会导致未定义行为。

4.C/C++ 中`static`的作用

静态局部变量：在函数内部用static修饰的局部变量，存储在全局数据区而非栈区。它的生命周期贯穿整个程序运行期间，在程序执行到其声明处时首次初始化，之后的函数调用不再初始化；若未显式初始化，会自动初始化为 0 。其作用域仍在定义它的函数内部。常用于记录函数调用次数或状态
静态全局变量：在全局变量前加static，该变量存储在全局数据区，作用域为声明它的文件，其他文件即使使用extern声明也无法访问。可提高程序的封装性，防止全局变量被意外修改，还能避免多文件项目中不同文件同名全局变量的命名冲突。比如在一个多人协作的大型项目中，每个源文件里的静态全局变量只在本文件内有效，不同文件可使用相同变量名。

静态函数：被static修饰的函数只能在声明它的文件中可见和调用，不能被其他文件使用。有助于提高程序的封装性，减少函数被其他文件错误调用的风险
类的静态数据成员：在类内数据成员声明前加static，该数据成员为类的所有对象共享，在程序中只有一份拷贝，存储在全局数据区。
类的静态成员函数：用static修饰的类成员函数，属于类本身而非类的对象，没有this指针，不能直接访问非静态成员变量和非静态成员函数。可在创建对象前调用，常作为工具函数或用于访问静态数据成员。

--------------------------------------------------------------------------------------------------------------------------------------关于一个函数的地址这里可以提到的是。函数名就是一个函数的地址！但是不能查地址的时候忽略作用域

关于函数指针问题：typedef void (*PluginFunction)();首先PluginFunction它是这个指针的别名，最后的一个括号说明这个指针可以用于没有参数的函数！

#include <iostream>// 定义一个插件函数
void pluginFunction() {std::cout << "This is a plugin function." << std::endl;
}// 使用函数指针类型表示插件函数类型
typedef void (*PluginFunction)();// 主程序加载插件并调用插件函数
void loadAndCallPlugin(PluginFunction func) {func();
}int main() {loadAndCallPlugin(pluginFunction);return 0;
}

从这个图也可以看出虚表也是存在于常量区代码段的位置！

5.多继承的虚表

//多继承的虚函数表
class Base1 {
public:virtual void func1() { std::cout << "Base1::func1" << std::endl; }virtual void func2() { std::cout << "Base1::func2" << std::endl; }
private:int b1;
};class Base2 {
public:virtual void func1() { std::cout << "Base2::func1" << std::endl; }virtual void func2() { std::cout << "Base2::func2" << std::endl; }
private:int b2;
};class Derive : public Base1, public Base2 {
public:virtual void func1() { std::cout << "Derive::func1" << std::endl; }virtual void func3() { std::cout << "Derive::func3" << std::endl; }
private:int d1;
};

derive内有两个虚表的原因：分别是Base1内的一个虚表，Base2一个续表，而func3会通过编译器自动放在一个已有的虚表中。

C++ 编译器为每个包含虚函数的类生成虚函数表，目的是为了实现运行时多态。当一个类继承自多个基类，且基类都有虚函数时，该派生类会继承基类的虚表结构。编译器通常会复用已有的虚表，将新的虚函数指针添加到合适的虚表中，而不是为每个新虚函数单独创建一个虚表。这样可以节省内存空间，并保持虚函数调用机制的一致性。