C++指针和引用到内存泄漏，内存对齐——面试八股素材库

坤坤爱技术~

已于 2024-05-27 09:03:06 修改

阅读量769

点赞数 16

分类专栏：数据结构二刷+算法模板文章标签： c++ 安全面试 linux

于 2024-05-27 07:42:07 首次发布

本文链接：https://blog.csdn.net/qq_36914923/article/details/139224896

版权

数据结构二刷+算法模板专栏收录该内容

3 篇文章 0 订阅

订阅专栏

参考《C++Primer》2.3 复合结构；

C++内存管理，内存泄漏，内存对齐

const int * ptr; 和 int const * ptr 和 int * const ptr; 区别

const int *ptr;

const int *ptr = &a; // 可以指向const int ptr = &b; // 可以更改ptr指向的地址那 * ptr的值是不是也变了？

使用#pragma pack指令（不推荐用于性能优化）：

指针和引用

指针：是一个变量，其值为另一个变量的地址。指针可以被重新赋值，指向不同的地址。指针本身有地址。

引用：是已存在变量的别名，必须在声明时初始化，且之后不能被重新赋值指向其他对象。引用没有自己的地址，它是被引用对象的别名。

引用和指针差别

引用（Reference）和指针（Pointer）在C++中都是用于间接访问其他变量的机制，但它们之间存在一些重要的差别和不同的用法。

引用

定义方式：在声明时必须初始化，且之后不能重新指向其他对象。
内存分配：引用不分配新的内存空间，它只是已有对象的别名。
空引用：不存在空引用，引用在定义时必须指向有效的对象。
访问：像操作普通变量一样使用引用。
用途：常用于函数参数传递（避免拷贝），以及返回局部变量的引用（但需注意生命周期问题）。

示例：

int x = 10;  
int& ref = x; // 引用ref是x的别名  
ref = 20;     // 相当于x = 20

指针

定义方式：可以在声明时不初始化，之后可以重新指向其他对象或地址。
内存分配：指针本身是一个变量，存储的是另一个对象的地址。指针可以指向堆（heap）或栈（stack）上的内存。
空指针：可以使用nullptr（或NULL、0）初始化指针，表示它不指向任何对象。
访问：需要通过解引用操作（*）来访问指针指向的内容。
用途：广泛用于动态内存管理（通过new和delete），数据结构（如链表、树等），以及函数参数传递（当需要修改原始数据时）。

示例：

int x = 10;  
int* ptr = &x; // 指针ptr存储了x的地址  
*ptr = 20;     // 相当于x = 20

具体用法差异

初始化：引用必须在声明时初始化，而指针可以在声明时留空，稍后再赋值。
重新赋值：引用一旦初始化，就不能重新指向其他对象；而指针可以随时改变指向。
空值：引用不能有“空值”状态，而指针可以有（即nullptr）。
操作：引用可以直接当作普通变量来用，不需要解引用；而指针需要解引用（*）才能访问其内容。
大小：引用和它所引用的对象在内存中占据相同的空间（没有额外的存储开销），而指针本身需要一定的内存空间来存储地址信息。
函数参数：对于函数参数来说，引用通常用于不希望修改指针本身（只修改指针指向的内容）的情况；而指针则提供了更多的灵活性，可以修改指针本身或指针指向的内容。
动态内存管理：指针常用于动态内存管理（如使用new和delete），而引用则不能用于动态内存分配。

常量指针和指向常量对象的指针

常量指针：指针本身是常量，不能被重新赋值指向新的地址，但指向的内容可以被修改（如果内容不是常量）。如int *const ptr = &var;

指向常量对象的指针：指针可以指向不同的常量地址，但指向的内容不能被修改。如const int *ptr = &constVar;

const：用于定义常量，表示值不能被修改。常用于函数参数（传递引用而不修改）、类成员变量（只读属性）、函数返回值（确保返回值不被修改）。

**const int * ptr; 和 int const * ptr 和 int * const ptr; 区别**

在C和C++中，const关键字与指针一起使用时，其位置决定了它所限制的是指针本身还是指针所指向的数据。

`const int *ptr;`

这里，const修饰的是int，而不是指针*ptr。这意味着指针ptr可以指向不同的int常量或非常量对象，但是你不能通过ptr来修改它所指向的整数值（因为它是常量）。

示例：

const int a = 5;  
int b = 10;  
const int *ptr = &a; // 可以指向const int  
ptr = &b; // 可以更改ptr指向的地址  
// *ptr = 20; // 错误！不能通过ptr修改所指向的值

int const *ptr;

这与const int *ptr;是完全相同的。在C++中，const的位置可以在类型之前或之后，但在这种情况下，它仍然修饰的是int，而不是指针。

int *const ptr;

这里，const修饰的是指针ptr本身，而不是它所指向的int。这意味着你不能改变ptr指向的地址，但是你可以通过ptr来修改它所指向的整数值（只要它不是const）。

示例：

int a = 5;  
int b = 10;  
int *const ptr = &a; // 初始化时必须指向某个地址  
// ptr = &b; // 错误！不能更改ptr指向的地址  
*ptr = 20; // 可以通过ptr修改所指向的值

为了更清晰地表达这些差异，你可以将const和*看作是一个整体，并考虑它们是从右向左阅读的（即“右左法则”）。这样，int *const ptr;就读作“ptr是一个指向整数的常量指针”，而const int *ptr;就读作“ptr是一个指向常量整数的指针”。

**const int ptr = &a; // 可以指向const int ptr = &b; // 可以更改ptr指向的地址那 ptr的值是不是也变了？**

const int a = 5;  
int b = 10;  
const int *ptr = &a; // 可以指向const int  
ptr = &b; // 可以更改ptr指向的地址

ptr 是一个指向 const int 的指针。这意味着 ptr 可以指向一个 const int 类型的变量（比如 a），或者一个非 const 的 int 类型的变量（比如 b），但是你不能通过 ptr 来修改它所指向的整数值。

当你执行 ptr = &b; 这行代码时，你实际上改变了 ptr 所指向的地址，让它从指向 a 变为指向 b。但是，这并不影响 *ptr 之前的值（即 a 的值），因为 a 被声明为 const int，所以它的值在初始化后就不能被修改。同时，这也并不意味着 *ptr 的值“自动”变为了 b 的值；它只是现在 ptr 指向了 b，所以 *ptr 将访问或表示 b 的值。

此时，*ptr 将会访问 b 的值（即 10），因为你已经将 ptr 重新指向了 b 的地址。但是，由于 ptr 是一个指向 const int 的指针，你仍然不能通过 ptr 来修改 b 的值（尽管 b 本身不是 const 的）。如果你尝试执行 *ptr = 20;，编译器将会报错，因为你不允许修改一个 const int 通过一个指向 const int 的指针。

总结：改变 ptr 所指向的地址不会改变之前所指向变量的值（除非那个变量本身就不是 const 的，并且你通过其他方式修改了它），但是会改变 ptr 本身所引用的值（即 *ptr 将会访问新的地址上的值）。

C++内存管理

内存泄漏

内存泄漏是指程序在申请内存后，未能释放不再使用的内存，导致系统内存的浪费，严重时可能导致程序崩溃。

示例：忘记释放动态分配的内存（如new或malloc）。

内存管理策略

使用智能指针（如std::unique_ptr、std::shared_ptr）来自动管理内存。

谨慎使用new和delete，确保每次new后都有对应的delete。

静态内存分配和动态内存分配的区别

静态内存分配：在编译时确定大小，并在程序的整个生命周期内存在（如全局变量、静态变量）。

动态内存分配：在运行时确定大小，通过new（在堆上）或malloc等函数分配内存，使用完后需要手动释放（通过delete或free）。

`new`和`malloc`的区别时：

类型安全：

new是C++的一个运算符，它返回的是指定类型的指针。这意味着当你使用new分配内存时，编译器会确保你得到的是正确类型的指针，这有助于在编译时捕获类型错误。

malloc是C语言库函数，它返回void*类型的指针。在C++中，你需要将malloc返回的void*指针显式地转换为正确的类型。这种类型转换可能会引入错误，因为编译器不会检查转换是否合法。如果类型转换错误，可能会导致运行时错误或未定义的行为。

构造函数与析构函数：

当使用new为一个对象分配内存时，编译器会自动调用该对象的构造函数（如果有的话）。同样地，当使用delete释放对象时，析构函数会被自动调用，用于执行清理工作，如释放资源或保存状态。

malloc和free只负责分配和释放内存，它们不会调用任何构造函数或析构函数。因此，如果你在使用malloc分配内存后创建了一个对象，你需要手动调用该对象的构造函数（如果可能的话）。同样地，在释放内存之前，你也需要手动调用析构函数（如果适用）。在C++中，这通常是不安全的，因为手动管理构造函数和析构函数的调用很容易出错。

异常处理：

new在内存分配失败时会抛出一个std::bad_alloc异常。这使得你可以使用C++的异常处理机制来优雅地处理内存分配失败的情况。你可以捕获std::bad_alloc异常，并执行适当的错误处理代码，如释放已经分配的资源、记录错误或尝试使用不同的内存分配策略。

malloc在内存分配失败时返回NULL。你需要手动检查malloc的返回值，以确定是否成功分配了内存。如果malloc返回NULL，你需要决定如何处理这种情况。在C++中，使用NULL检查来处理内存分配失败通常不如使用异常处理机制那么优雅和灵活。

内存对齐：

new会考虑对象的内存对齐需求。编译器会确保对象的地址是适当的对齐边界的倍数，以满足硬件访问数据的效率要求。这种对齐通常是自动的，你不需要手动干预。

malloc通常只保证分配的内存块的大小满足要求，但不保证内存对齐。在某些情况下，你可能需要手动进行内存对齐，以确保数据按预期的方式存储和访问。手动对齐可能会增加编程的复杂性，并需要你对硬件和内存管理有深入的了解。

可维护性和可移植性：

new是C++语言的一部分，它符合C++的编程范式和最佳实践。使用new分配内存可以使你的代码更易于理解和维护，因为它与其他C++特性（如类、异常处理等）无缝集成。

malloc和free是C语言库函数，它们与C++的某些特性（如类和异常处理）不直接兼容。在C++代码中使用malloc和free可能会导致代码风格不一致、错误处理困难以及可移植性问题。因此，在C++中，通常建议优先使用new和delete来管理内存。

new和malloc示例：

当然可以，以下是一些示例，用于更好地理解new和malloc之间的区别：

1. 类型安全

使用new（类型安全）

class MyClass {  
public:  
    int value;  
    MyClass(int v) : value(v) {}  
};  
  
int main() {  
    MyClass* ptr = new MyClass(10); // 正确，编译器知道类型并调用构造函数  
    // ... 使用ptr ...  
    delete ptr; // 正确，编译器知道类型并调用析构函数  
    return 0;  
}

使用malloc（类型不安全）

class MyClass {  
public:  
    int value;  
    MyClass(int v) : value(v) {}  
};  
  
int main() {  
    MyClass* ptr = (MyClass*)malloc(sizeof(MyClass)); // 需要显式转换，且不会调用构造函数  
    if (ptr != nullptr) {  
        ptr->value = 10; // 需要手动初始化成员变量  
        // ... 使用ptr ...  
        // 注意：这里没有调用析构函数，因为malloc不会管理这个  
        free(ptr); // 使用free而不是delete  
    }  
    return 0;  
}malloc不会管理这个  free(ptr); // 使用free而不是delete      }  return0;  }

2. 构造函数与析构函数

使用new（自动调用）

class MyClass {  
public:  
    MyClass() { /* 构造函数代码 */ }  
    ~MyClass() { /* 析构函数代码 */ }  
};  
  
int main() {  
    MyClass* ptr = new MyClass(); // 构造函数被自动调用  
    // ... 使用ptr ...  
    delete ptr; // 析构函数被自动调用  
    return 0;  
}

使用malloc（需要手动管理）

（与上面的例子相同，但注意没有自动的构造函数/析构函数调用）

3. 异常处理

使用new（异常处理）

int main() {  
    try {  
        MyClass* ptr = new MyClass[1000000000]; // 尝试分配大量内存，可能会失败  
        // ... 使用ptr ...  
        delete[] ptr;  
    } catch (const std::bad_alloc& e) {  
        // 处理内存分配失败的情况  
        std::cerr << "Memory allocation failed: " << e.what() << '\n';  
    }  
    return 0;  
}

使用malloc（需要手动检查返回值）

int main() {  
    MyClass* ptr = (MyClass*)malloc(sizeof(MyClass) * 1000000000); // 尝试分配大量内存  
    if (ptr == nullptr) {  
        // 处理内存分配失败的情况  
        std::cerr << "Memory allocation failed\n";  
    } else {  
        // 手动初始化对象（如果需要）  
        // ... 使用ptr ...  
        free(ptr);  
    }  
    return 0;  
}

4. 内存对齐

内存对齐的示例通常与硬件和平台相关，但在大多数情况下，你不需要手动处理内存对齐，因为编译器会为你做这件事。然而，如果你确实需要手动对齐内存（例如，使用某些特定的硬件加速功能），那么使用malloc并配合手动对齐代码将比使用new更加复杂。

总结

在C++中，通常推荐使用new和delete来管理动态内存分配，因为它们提供了类型安全、自动的构造函数/析构函数调用以及更好的异常处理机制。而malloc和free则主要用于C语言编程，或者在需要更底层控制内存分配的场景下使用。在C++代码中，尽量避免使用malloc和free，除非有特别的理由。

C++内存对齐

C++内存对齐（Memory Alignment）是计算机硬件为了提高数据访问效率而采用的一种技术。当数据在内存中的地址是某个特定值的倍数时，处理器可以更快地访问这些数据。这个特定值通常被称为对齐边界（Alignment Boundary）或对齐要求（Alignment Requirement）。

在C++中，编译器会自动处理大多数内存对齐问题，但有时候你可能需要手动控制对齐，特别是在处理硬件相关的代码或优化性能时。

为什么需要内存对齐？

内存对齐可以提高数据访问的效率，因为处理器通常可以更快地访问对齐的数据。此外，某些硬件平台可能要求特定的数据类型必须按特定的方式对齐，否则可能会导致硬件异常或性能下降。

对齐的影响

性能：对齐的数据可以更快地被处理器访问，从而提高程序的性能。
空间利用率：过度对齐可能会浪费内存空间，因为编译器可能需要在对象之间插入填充字节（Padding）以满足对齐要求。
可移植性：不同的硬件平台可能有不同的对齐要求。编写不依赖于特定对齐要求的代码可以提高代码的可移植性。

总结

C++提供了自动和手动控制内存对齐的机制。在大多数情况下，你可以依赖编译器来自动处理内存对齐问题。然而，在处理硬件相关的代码或优化性能时，你可能需要手动控制对齐。使用alignas关键字或编译器特定的扩展可以实现这一点。

当处理硬件相关的代码或优化性能时，手动控制内存对齐可能变得至关重要。以下是关于手动控制内存对齐的详细解释，结合了参考文章中的相关信息：

为什么需要手动控制内存对齐？

硬件要求：不是所有硬件平台都能访问到任意地址上的任意数据。在嵌入式系统或某些特定的硬件架构中，数据必须在特定的地址边界上对齐，否则可能会导致硬件异常或性能下降。
性能优化：处理器在访问对齐的数据时通常更加高效。例如，如果处理器的字长是4字节，那么它一次可以读取4个字节的数据。如果数据没有对齐到4字节的边界，那么处理器可能需要读取两次内存来获取所需的数据，这会降低性能。

如何手动控制内存对齐？

使用alignas关键字（C++11及以上）：

alignas关键字允许你为类型或变量指定一个特定的对齐要求。

例如，alignas(16) struct MyStruct {...}; 会确保MyStruct类型的对象在内存中的地址是16字节的倍数。

使用编译器特定的属性或扩展：

对于GCC和Clang编译器，可以使用__attribute__((aligned(N)))来为类型或变量指定对齐要求。

例如，struct MyStruct __attribute__((aligned(16))) {...}; 也会产生与alignas(16)相同的效果。

使用`#pragma pack`指令（不推荐用于性能优化）：

#pragma pack通常用于控制结构体或类的内存布局，但它并不直接控制对齐。

#pragma pack(push, 1)可以去除填充字节，导致内存访问性能下降，因为数据可能不再对齐。

手动控制内存对齐的影响

性能提升：通过确保数据按处理器的最佳方式对齐，可以显著提高内存访问的速度，从而优化性能。
硬件兼容性：在某些硬件平台上，正确的内存对齐是确保代码正确运行的关键。
空间利用率：手动控制对齐可能会导致内存空间的浪费，因为编译器可能需要插入额外的填充字节来满足对齐要求。然而，在性能关键的应用中，这种浪费通常是值得的。

具体内存对齐实现举例

C++11以下内存对齐实现方式

在C++11以下版本或C语言中，实现内存对齐的方法主要依赖于编译器特定的扩展属性或指令。这些方法不是标准C++或C的一部分，但在大多数编译器中都得到了支持。

在C++11以下实现内存对齐

对于C++11以下版本，你可以使用编译器的特定属性来实现内存对齐。例如，在GCC和Clang中，你可以使用__attribute__((aligned(N)))来指定对齐要求。

// 在C++03或更早版本中  
struct alignas_example {  
    int x;  
} __attribute__((aligned(16))); // GCC和Clang特定的扩展  
  
// 创建一个对齐的对象  
alignas_example* ptr = (alignas_example*)aligned_alloc(16, sizeof(alignas_example));

注意，在C++中，aligned_alloc函数是C11标准的一部分，但在C++03或更早版本中并不是标准库的一部分。不过，很多C++编译器都提供了对它的支持。

在C语言中使用对齐属性

在C语言中，你可以使用与C++相同的编译器特定属性来实现内存对齐。例如，在GCC和Clang中：

// C语言  
typedef struct {  
    int x;  
} alignas_example __attribute__((aligned(16))); // GCC和Clang特定的扩展  
  
// 创建一个对齐的对象  
alignas_example* ptr = (alignas_example*)aligned_alloc(16, sizeof(alignas_example));

同样地，aligned_alloc函数在C11及更高版本中才是标准库的一部分，但在早期的C标准中并不是。

C++17中的`alignas`关键字

在C++17中，引入了alignas关键字作为标准的一部分，用于指定类型、变量或对象的对齐要求。这是C++标准中处理内存对齐的首选方法。

// C++17及更高版本  
alignas(16) struct alignas_example {  
    int x;  
};  
  
// 创建一个对齐的对象（使用new操作符和自定义删除器）  
alignas_example* ptr = new (std::align_val_t(16)) alignas_example;  
// ... 使用ptr ...  
// 释放内存时，你需要提供一个自定义的删除器来调用析构函数并释放内存  
// 注意：直接使用new和delete在这里可能不安全，因为标准库没有为alignas提供直接的new/delete重载

然而，直接使用new和delete与alignas结合并不安全，因为标准库并没有为alignas提供直接的new和delete重载。为了安全地分配和释放对齐的内存，你可以使用aligned_alloc（在C++中可能需要自己封装）或自定义的分配器。

其他方法

除了使用编译器特定的属性和C++17的alignas关键字外，还有其他一些方法可以实现内存对齐：