第 8 天：5 个高频 C++ 内存管理问题

最编程 2024-06-27 09:30:06

...

1、什么是内存泄漏？如何避免它？

内存泄漏是指在程序中已分配的内存未被正确释放，导致该部分内存在程序运行期间一直占用而无法被再次使用的现象。这会逐渐消耗系统的内存资源，可能导致程序运行缓慢甚至崩溃。在C++中，内存泄漏主要发生在使用动态内存分配时。

如何避免内存泄漏：

1. **正确使用 `new` 和 `delete`**：
- 每次使用 `new` 分配内存后，都应确保在适当的时机使用 `delete` 释放内存。对于数组，使用 `new[]` 和 `delete[]`。

2. **使用智能指针**：
- C++11及之后的版本中，推荐使用智能指针（如 `std::unique_ptr`、`std::shared_ptr`）来自动管理内存。这些智能指针可以在对象不再被使用时自动释放其占用的内存。

3. **避免内存泄漏常见陷阱**：
- 避免指针悬挂（悬空指针）：确保不再使用已释放的内存。
- 避免重复释放：确保不对同一块内存进行多次释放。
- 解决循环引用：在使用 `std::shared_ptr` 时，避免创建循环引用，可能需要使用 `std::weak_ptr`。

4. **确保异常安全**：
- 在可能抛出异常的代码中，确保在异常发生时也能释放已分配的内存。使用RAII（Resource Acquisition Is Initialization）模式可以帮助实现这一点。

5. **定期检查和测试**：
- 使用内存泄漏检测工具，如 Valgrind、Visual Studio 的内存诊断工具等，定期检查程序以发现并修复内存泄漏问题。

通过这些方法，可以有效避免内存泄漏，保持程序的健壮性和效率。

2. 在C++中，什么是动态内存分配？请举例说明。

在C++中，动态内存分配是指在程序运行时（而不是在编译时）分配和释放内存的过程。这种方式允许程序根据实际需要和可用内存动态地分配内存大小。动态内存分配主要通过 new 和 delete 关键字进行。

举例说明：

分配单个变量:

假设你需要在运行时根据用户输入创建一个整数。你可以这样做：

int* ptr = new int;
*ptr = 用户输入的值;

这里，new int 动态地在堆上分配了一个整型变量的内存。ptr 是一个指向这块内存的指针。

分配数组:

如果你需要一个大小在运行时才能确定的数组，可以这样做：

int size = 用户输入的大小;
int* array = new int[size];

这里，new int[size] 动态地在堆上分配了一个大小为 size 的整型数组。

释放内存:

使用完动态分配的内存后，你需要用 delete（对于单个变量）或 delete[]（对于数组）来释放这些内存：

delete ptr;       // 释放单个变量
delete[] array;   // 释放数组

这样做可以避免内存泄漏。

动态内存分配在许多场景中非常有用，特别是在处理大小不确定的数据结构（如数组、链表、树）时。但是，它也要求程序员负责手动管理内存，包括正确地分配和释放内存，避免内存泄漏和其他内存管理问题。

3. 如何构造一个类，使得只能在堆上或只能在栈上分配内存？

要构造一个类，使其实例只能在堆上或只能在栈上分配内存，我们可以通过控制类的构造函数、析构函数和操作符 new 的可访问性来实现。

只能在堆上分配内存的类

要使类的实例只能在堆上分配，可以将其析构函数设置为私有。这样，在栈上创建对象将会导致编译错误，因为栈上的对象在离开作用域时会自动调用析构函数，而私有析构函数在类外部是不可访问的。

class HeapOnly {
public:
    static HeapOnly* create() {
        return new HeapOnly();
    }

    void destroy() {
        delete this;
    }

private:
    HeapOnly() {} // 私有构造函数
    ~HeapOnly() {} // 私有析构函数
};

使用方法:

HeapOnly* obj = HeapOnly::create();
// ...
obj->destroy();

只能在栈上分配内存的类

要使类的实例只能在栈上分配，可以将其操作符 new 设置为私有。这样，使用 new 尝试在堆上分配对象时，会遇到编译错误。

class StackOnly {
public:
    StackOnly() {}
    ~StackOnly() {}

private:
    void* operator new(size_t) = delete; // 禁用new操作符
    void operator delete(void*) = delete; // 禁用delete操作符
};

使用方法:

StackOnly obj; // 正确
// StackOnly* obj = new StackOnly(); // 错误：不能在堆上分配

在设计这样的类时，需要注意确保类的使用符合预期的内存分配方式。例如，只能在堆上分配的类，应提供安全的创建和销毁机制，以确保资源的正确管理。而只能在栈上分配的类，则要确保不会被误用于动态内存分配。

4. 请解释指针在内存中的表现形式。

在C++中，指针是一种特殊的数据类型，它存储了另一个变量的内存地址。指针在内存中的表现形式，实际上就是一个存储地址的变量。这个地址指向被引用变量的内存位置。

举个例子，假设我们有一个整型变量 int a = 10;，它被存储在内存的某个位置。当我们创建一个指向 a 的指针，如 int* p = &a;，这个指针 p 就存储了变量 a 的内存地址。在32位系统中，指针通常是4个字节大小；在64位系统中，指针大小通常是8个字节。

在实际的应用场景中，指针非常有用，因为它们允许我们间接地访问和修改内存中的数据。例如，在处理数组、字符串或传递大型数据结构给函数时，使用指针可以提高效率，因为我们只需要传递数据的地址，而不是复制整个数据结构。此外，指针也是实现动态内存分配（如使用 new 和 delete）的基础。

5.指针变量和引用变量在内存管理上有何不同？

指针变量和引用变量在C++中都用于间接引用其他变量，但它们在内存管理上有一些关键区别：

定义和赋值:

指针变量：指针是一个存储内存地址的变量。指针可以被初始化为 nullptr，表示它不指向任何地址，也可以在声明后重新赋值以指向不同的地址。
引用变量：引用是一个已声明的变量的别名。一旦一个引用被初始化指向一个变量，它就不能改变指向别的变量。引用在声明时必须被初始化。

内存占用:

指针变量：占用固定大小的内存（通常是4或8字节，取决于操作系统的位数）。
引用变量：引用本身不占用额外的内存，因为它只是原始变量的别名。

使用:

指针变量：可以指向 nullptr，也就是说，指针可以没有指向任何实际的变量。
引用变量：必须总是指向一个有效的对象，不能指向 nullptr。

操作符:

指针变量：使用 *（解引用操作符）来访问或修改指针指向的值。
引用变量：直接使用引用名称即可操作其指向的值，无需特殊操作符。

在应用场景中，引用通常用于函数参数传递和返回值，使得代码更简洁和易于理解。例如，在函数参数传递时，使用引用可以避免复制整个对象，从而提高效率。而指针则广泛用于动态内存管理、数组操作等场景。由于指针可以重新指向不同的对象，它在处理动态数据结构（如链表、树等）时非常有用。

指针常量、常量指针和引用（本质是 *const）This的理解_const 的三种用法:指向常量的指针,常指针,指向常量的常指针-****博客

一级指针、二级指针做函数参数的深入剖析_函数里一级指针参数修改-****博客

上一篇：学习笔记标签从右向左滚动和父容器内左右移动的方法（附代码）

下一篇：用 Swift 与 WebView 交互