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 的三种用法:指向常量的指针,常指针,指向常量的常指针-CSDN博客

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