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. 内存泄漏和释放
- 内存泄漏的定义和原因。
- 如何避免内存泄漏。
- 显式释放内存的重要性。
内存泄漏的定义和原因
内存泄漏是指在程序运行期间未能释放不再需要的内存，导致内存资源的浪费。这可能会导致程序性能下降，甚至崩溃。
内存泄漏通常发生在以下情况下：
- 忘记释放动态分配的内存。
- 丢失对动态分配内存的指针，无法再释放它。
- 重复分配内存，丢失对之前分配内存的指针。
如何避免内存泄漏
为了避免内存泄漏，我们可以采取以下措施：
- 始终在使用完动态分配内存后记得使用
delete或delete[]来释放它。例如：
int* dynamicInt = new int;
// 使用dynamicInt
delete dynamicInt; // 释放内存
- 使用智能指针（例如
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，并在程序结束时检查字符串是否被释放。
