十四天学会C++之第九天：内存管理

1. new和delete运算符

• new运算符：动态分配内存。
• delete运算符：释放动态分配的内存。

new运算符：动态分配内存

new运算符的作用是在堆内存中动态分配内存块，并返回指向该内存块的指针。这使得我们能够在程序运行时创建变量，而不必在编译时知道其大小。

如何使用new来动态分配一个整数：

int* dynamicInt = new int;
*dynamicInt = 42; // 给动态分配的整数赋值

我们首先使用new分配了一个整数大小的内存块，然后通过指针dynamicInt来访问它。请注意，一定要记得在不再需要这块内存时使用delete来释放它，以免造成内存泄漏。

delete运算符：释放动态分配的内存

如何使用delete运算符来释放动态分配的内存。它的语法很简单，只需使用delete后跟要释放的指针即可：

delete dynamicInt; // 释放动态分配的整数内存

相当于告诉编译器我们不再需要这块内存，它可以被回收以供其他用途。请注意，如果忘记释放动态分配的内存，将会导致内存泄漏，这会严重影响程序性能。

动态内存管理的责任

在使用new和delete时，要格外小心。内存泄漏是一个常见的问题，可以通过良好的内存管理来避免。确保在不再需要动态分配的内存时及时释放它，以确保程序的稳定性和性能。

代码示例

#include <iostream>

int main() {
    // 使用new分配动态内存
    int* dynamicInt = new int;
    *dynamicInt = 42;

    // 使用delete释放内存
    delete dynamicInt;

    return 0;
}

演示如何使用new和delete运算符来分配和释放动态内存。记住，合理的内存管理是编程中不可或缺的一部分，可以帮助我们编写高效且稳定的程序。

2. 动态内存分配

• 动态内存分配的概念和重要性。
• 使用new动态分配内存。
• 使用delete释放动态分配的内存。

动态内存分配的概念

与静态内存分配不同，动态内存分配发生在程序运行时，而不是在编译时。这意味着我们可以根据需要分配内存，而不必提前知道内存的大小或生命周期。

动态内存分配的重要性在于，它允许我们创建变量、数据结构和对象，这些可以根据程序的运行情况进行调整，从而更好地适应不同的应用场景。

使用new动态分配内存

在C++中，我们使用new运算符来执行动态内存分配。

int* dynamicInt = new int;
*dynamicInt = 42; // 给动态分配的整数赋值

我们使用new分配了一个整数大小的内存块，并将其地址存储在dynamicInt指针中。然后，可以通过指针来访问和操作这块内存。

使用delete释放动态分配的内存

与动态分配内存一样重要的是释放它，以防止内存泄漏。我们使用delete运算符来释放动态分配的内存。下面是释放前面动态分配的整数内存的代码：

delete dynamicInt; // 释放动态分配的整数内存

通过调用delete dynamicInt，我们告诉编译器不再需要这块内存，可以将其释放以供其他用途。这个步骤至关重要，因为不释放动态分配的内存会导致内存泄漏，严重影响程序性能和稳定性。

3. 指针和引用

• 指针和引用的基本概念。
• 如何使用指针和引用来管理动态分配的内存。

指针和引用的基本概念

指针是一个变量，它存储了另一个变量的地址。通过指针，可以直接访问和操作存储在该地址上的数据。

引用是一个别名，它允许我们通过不同的名称访问相同的变量。引用通常用于函数参数和返回值，以便避免复制大量数据。

使用指针管理动态内存

指针在动态内存管理中非常有用。通过指针，可以轻松地访问和修改动态分配的内存。

如何使用指针来管理动态分配的整数数组：

int* dynamicArray = new int[5]; // 动态分配整数数组
dynamicArray[0] = 1;
dynamicArray[1] = 2;
// ...
delete[] dynamicArray; // 释放动态分配的数组内存

首先使用new分配了一个包含5个整数的数组，并将其地址存储在dynamicArray指针中。然后，可以使用指针访问数组的元素，并最终使用delete[]释放内存。

使用引用管理动态内存

引用通常用于管理动态分配的内存时传递参数。如何在函数中使用引用来修改动态分配的整数：

void modifyDynamicInt(int& x) {
    x = 42;
}

int main() {
    int* dynamicInt = new int;
    modifyDynamicInt(*dynamicInt);
    // dynamicInt现在包含值42
    delete dynamicInt;
    return 0;
}

定义一个接受整数引用的函数modifyDynamicInt。通过在main函数中使用引用，可以直接修改动态分配的整数，而不必担心指针或复制数据。

4. 内存泄漏和释放

• 内存泄漏的定义和原因。
• 如何避免内存泄漏。
• 显式释放内存的重要性。

内存泄漏的定义和原因

内存泄漏是指在程序运行期间未能释放不再需要的内存，导致内存资源的浪费。这可能会导致程序性能下降，甚至崩溃。

内存泄漏通常发生在以下情况下：

1. 忘记释放动态分配的内存。
2. 丢失对动态分配内存的指针，无法再释放它。
3. 重复分配内存，丢失对之前分配内存的指针。

如何避免内存泄漏

为了避免内存泄漏，我们可以采取以下措施：

1. 始终在使用完动态分配内存后记得使用delete或delete[]来释放它。例如：

int* dynamicInt = new int;
// 使用dynamicInt
delete dynamicInt; // 释放内存

1. 使用智能指针（例如std::shared_ptr和std::unique_ptr），它们会自动管理内存释放，避免手动释放内存的麻烦。

显式释放内存的重要性

即使在现代C++中，智能指针等工具可以帮助我们更轻松地管理内存，但了解如何显式释放内存仍然是一个重要的技能。直接管理内存资源，或者与遗留代码交互，这时手动释放内存是必要的。

5. 示例和练习

示例 1：动态分配和释放内存

#include <iostream>

int main() {
    // 动态分配一个整数
    int* dynamicInt = new int;
    
    // 检查内存是否成功分配
    if (dynamicInt == nullptr) {
        std::cerr << "内存分配失败" << std::endl;
        return 1;
    }
    
    // 使用动态分配的整数
    *dynamicInt = 42;
    
    // 释放内存
    delete dynamicInt;
    
    return 0;
}

示例 2：使用智能指针

#include <iostream>
#include <memory>

int main() {
    // 使用std::unique_ptr自动管理内存释放
    std::unique_ptr<int> smartInt = std::make_unique<int>(42);
    
    // 不需要手动释放内存
    
    // 使用智能指针时，当超出作用域时内存会自动释放
    
    return 0;
}

练习题

动态分配字符数组并释放内存

#include <iostream>

int main() {
    // 动态分配一个字符数组
    int size = 10;
    char* dynamicArray = new char[size];
    
    // 检查内存是否成功分配
    if (dynamicArray == nullptr) {
        std::cerr << "内存分配失败" << std::endl;
        return 1;
    }
    
    // 使用动态分配的字符数组
    for (int i = 0; i < size; ++i) {
        dynamicArray[i] = 'A' + i;
    }
    
    // 打印字符数组内容
    for (int i = 0; i < size; ++i) {
        std::cout << dynamicArray[i] << " ";
    }
    std::cout << std::endl;
    
    // 释放内存
    delete[] dynamicArray;
    
    return 0;
}

运行结果：

动态分配了一个字符数组，使用循环填充了它，然后在程序结束时使用delete[]释放了内存。

示例 2：创建函数模板来计算和

#include <iostream>

// 创建一个函数模板，计算两个数的和
template <typename T>
T calculateSum(T a, T b) {
    return a + b;
}

int main() {
    // 使用函数模板计算整数和浮点数的和
    int intSum = calculateSum(5, 3);
    double doubleSum = calculateSum(2.5, 3.7);
    
    std::cout << "整数和: " << intSum << std::endl;
    std::cout << "浮点数和: " << doubleSum << std::endl;
    
    return 0;
}

运行结果：

我们定义一个函数模板calculateSum，它可以接受不同类型的参数，并返回它们的和。然后在main函数中使用该模板来计算整数和浮点数的和。

示例 3：创建一个通用的容器类模板

#include <iostream>
#include <vector>
#include <string>

// 创建一个通用的容器类模板
template <typename T>
class GenericContainer {
public:
    // 构造函数
    GenericContainer() {}

    // 添加元素到容器
    void add(const T& item) {
        container.push_back(item);
    }

    // 打印容器中的元素
    void print() {
        for (const T& item : container) {
            std::cout << item << " ";
        }
        std::cout << std::endl;
    }

private:
    std::vector<T> container;
};

int main() {
    // 使用容器类模板存储整数
    GenericContainer<int> intContainer;
    intContainer.add(5);
    intContainer.add(10);
    intContainer.add(15);

    // 使用容器类模板存储字符串
    GenericContainer<std::string> strContainer;
    strContainer.add("Hello");
    strContainer.add("World");

    // 打印整数容器
    std::cout << "整数容器中的元素: ";
    intContainer.print();

    // 打印字符串容器
    std::cout << "字符串容器中的元素: ";
    strContainer.print();

    return 0;
}

运行结果：

创建一个通用的容器类模板GenericContainer，它可以存储不同类型的数据。我们使用它来存储整数和字符串，并在main函数中打印它们的内容。

示例 4：动态分配整数数组并计算平均值

#include <iostream>

int main() {
    // 动态分配整数数组
    int size = 5;
    int* scores = new int[size];

    // 输入分数
    std::cout << "请输入 " << size << " 个分数:" << std::endl;
    for (int i = 0; i < size; ++i) {
        std::cin >> scores[i];
    }

    // 计算平均值
    int sum = 0;
    for (int i = 0; i < size; ++i) {
        sum += scores[i];
    }
    double average = static_cast<double>(sum) / size;

    std::cout << "平均值: " << average << std::endl;

    // 释放内存
    delete[] scores;

    return 0;
}

运行结果：

动态分配了一个整数数组，然后输入分数并计算它们的平均值，最后使用delete[]释放了内存。

示例 5：使用智能指针std::shared_ptr管理字符串

#include <iostream>
#include <memory>
#include <vector>

int main() {
    // 创建一个vector来存储shared_ptr
    std::vector<std::shared_ptr<std::string>> stringPtrs;

    // 添加字符串到vector
    stringPtrs.push_back(std::make_shared<std::string>("Hello"));
    stringPtrs.push_back(std::make_shared<std::string>("World"));

    // 打印字符串
    for (const auto& ptr : stringPtrs) {
        std::cout << *ptr << " ";
    }
    std::cout << std::endl;

    // 检查字符串是否被释放
    std::cout << "检查字符串是否被释放:" << std::endl;
    for (const auto& ptr : stringPtrs) {
        if (ptr.unique()) {
            std::cout << "字符串 \"" << *ptr << "\" 已被释放" << std::endl;
        } else {
            std::cout << "字符串 \"" << *ptr << "\" 仍然存在" << std::endl;
        }
    }

    return 0;
}

运行结果：

使用std::shared_ptr来管理一组字符串。添加两个字符串到stringPtrs vector，并在程序结束时检查字符串是否被释放。