当前位置：首页 > news >正文

C++内存管理核心：常量、指针与new/delete实战详解

news 2026/7/16 8:08:10

在C++编程中，内存管理是每个开发者必须掌握的核心技能。很多初学者在使用new和delete进行动态内存分配时，经常会遇到内存泄漏、重复释放等问题。本文将系统讲解C++中的常量、指针、new和delete运算符以及函数的相关知识，通过完整代码示例帮助大家构建扎实的内存管理基础。

1. C++常量详解

1.1 常量的基本概念

常量是指在程序运行期间其值不可改变的标识符。在C++中，使用const关键字来定义常量，这有助于提高代码的可读性和安全性。

#include <iostream> using namespace std; int main() { // 基本常量定义 const int MAX_SIZE = 100; const double PI = 3.14159; const char* COMPANY_NAME = "Tech Corp"; // 以下代码会导致编译错误 // MAX_SIZE = 200; // 错误：不能修改常量 cout << "最大尺寸: " << MAX_SIZE << endl; cout << "圆周率: " << PI << endl; cout << "公司名称: " << COMPANY_NAME << endl; return 0; }

1.2 常量指针与指针常量

这是C++中容易混淆的概念，需要仔细区分：

#include <iostream> using namespace std; int main() { int a = 10, b = 20; // 1. 指向常量的指针（常量指针） const int* ptr1 = &a; // *ptr1 = 30; // 错误：不能通过ptr1修改指向的值 ptr1 = &b; // 正确：可以改变指针的指向 // 2. 指针常量 int* const ptr2 = &a; *ptr2 = 30; // 正确：可以通过ptr2修改指向的值 // ptr2 = &b; // 错误：不能改变指针的指向 // 3. 指向常量的指针常量 const int* const ptr3 = &a; // *ptr3 = 40; // 错误：不能修改值 // ptr3 = &b; // 错误：不能修改指向 cout << "a的值: " << a << endl; cout << "通过ptr2修改后的a: " << *ptr2 << endl; return 0; }

1.3 常量成员函数

在类中，常量成员函数承诺不修改对象的成员变量：

#include <iostream> #include <string> using namespace std; class Student { private: string name; int age; public: Student(string n, int a) : name(n), age(a) {} // 常量成员函数 - 不会修改对象状态 string getName() const { return name; } int getAge() const { return age; } // 非常量成员函数 - 可以修改对象状态 void setAge(int newAge) { age = newAge; } // 显示信息（常量函数） void display() const { cout << "姓名: " << name << ", 年龄: " << age << endl; } }; int main() { Student student("张三", 20); const Student constStudent("李四", 22); student.display(); // 正确 constStudent.display(); // 正确：常量对象只能调用常量成员函数 student.setAge(21); // 正确 // constStudent.setAge(23); // 错误：常量对象不能调用非常量成员函数 return 0; }

2. 指针深入解析

2.1 指针的基本操作

指针是C++中强大的特性，但也容易出错：

#include <iostream> using namespace std; int main() { int num = 42; int* ptr = &num; cout << "变量num的值: " << num << endl; cout << "变量num的地址: " << &num << endl; cout << "指针ptr的值（存储的地址）: " << ptr << endl; cout << "指针ptr指向的值: " << *ptr << endl; cout << "指针ptr自己的地址: " << &ptr << endl; // 指针运算 int arr[] = {10, 20, 30, 40, 50}; int* arrPtr = arr; cout << "\n数组元素访问:" << endl; for(int i = 0; i < 5; i++) { cout << "arr[" << i << "] = " << *(arrPtr + i) << " (地址: " << (arrPtr + i) << ")" << endl; } return 0; }

2.2 多级指针

理解指针的指针对于高级编程很重要：

#include <iostream> using namespace std; int main() { int value = 100; int* ptr = &value; int** ptrToPtr = &ptr; int*** ptrToPtrToPtr = &ptrToPtr; cout << "value: " << value << endl; cout << "ptr指向的值: " << *ptr << endl; cout << "ptrToPtr指向的值: " << **ptrToPtr << endl; cout << "ptrToPtrToPtr指向的值: " << ***ptrToPtrToPtr << endl; cout << "\n地址分析:" << endl; cout << "value的地址: " << &value << endl; cout << "ptr的值（存储的地址）: " << ptr << endl; cout << "ptr的地址: " << &ptr << endl; cout << "ptrToPtr的值: " << ptrToPtr << endl; // 修改多级指针指向的值 ***ptrToPtrToPtr = 200; cout << "\n修改后value的值: " << value << endl; return 0; }

2.3 函数指针

函数指针允许我们将函数作为参数传递：

#include <iostream> using namespace std; // 普通函数 int add(int a, int b) { return a + b; } int multiply(int a, int b) { return a * b; } // 使用函数指针作为参数的函数 void calculate(int x, int y, int (*operation)(int, int)) { int result = operation(x, y); cout << "计算结果: " << result << endl; } // 回调函数示例 void processArray(int arr[], int size, void (*callback)(int)) { for(int i = 0; i < size; i++) { callback(arr[i]); } } void printNumber(int num) { cout << num << " "; } void printSquare(int num) { cout << num * num << " "; } int main() { // 函数指针的声明和赋值 int (*funcPtr)(int, int); funcPtr = add; cout << "加法结果: " << funcPtr(5, 3) << endl; funcPtr = multiply; cout << "乘法结果: " << funcPtr(5, 3) << endl; // 函数指针作为参数 cout << "\n使用函数指针参数:" << endl; calculate(10, 20, add); calculate(10, 20, multiply); // 回调函数示例 int numbers[] = {1, 2, 3, 4, 5}; cout << "\n原始数组: "; processArray(numbers, 5, printNumber); cout << "\n平方数组: "; processArray(numbers, 5, printSquare); cout << endl; return 0; }

3. new和delete运算符

3.1 基本动态内存分配

new和delete是C++中用于动态内存管理的关键运算符：

#include <iostream> using namespace std; int main() { // 动态分配单个变量 int* dynamicInt = new int; *dynamicInt = 42; cout << "动态分配的整数: " << *dynamicInt << endl; // 动态分配数组 int size = 5; int* dynamicArray = new int[size]; // 初始化数组 for(int i = 0; i < size; i++) { dynamicArray[i] = i * 10; } cout << "动态数组内容: "; for(int i = 0; i < size; i++) { cout << dynamicArray[i] << " "; } cout << endl; // 动态分配对象 class Point { public: int x, y; Point(int x, int y) : x(x), y(y) {} void display() { cout << "Point(" << x << ", " << y << ")" << endl; } }; Point* pointPtr = new Point(3, 4); pointPtr->display(); // 必须释放内存！ delete dynamicInt; delete[] dynamicArray; delete pointPtr; // 将指针设置为nullptr防止悬空指针 dynamicInt = nullptr; dynamicArray = nullptr; pointPtr = nullptr; return 0; }

3.2 内存分配失败处理

动态内存分配可能失败，需要适当处理：

#include <iostream> #include <new> // 包含bad_alloc异常 using namespace std; int main() { // 方法1：使用try-catch捕获异常 try { int* hugeArray = new int[1000000000000LL]; // 极大内存分配 delete[] hugeArray; } catch (const bad_alloc& e) { cout << "内存分配失败: " << e.what() << endl; } // 方法2：使用nothrow版本 int* largeArray = new(nothrow) int[1000000000000LL]; if (largeArray == nullptr) { cout << "nothrow内存分配失败" << endl; } else { delete[] largeArray; } // 方法3：自定义new handler void customNewHandler() { cout << "自定义内存分配处理器被调用" << endl; // 可以尝试释放一些内存或抛出异常 throw bad_alloc(); } // 设置自定义处理器 set_new_handler(customNewHandler); try { int* anotherArray = new int[1000000000000LL]; delete[] anotherArray; } catch (const bad_alloc& e) { cout << "自定义处理器捕获异常" << endl; } return 0; }

3.3 重载new和delete运算符

可以自定义内存管理行为：

#include <iostream> #include <cstdlib> // 包含malloc和free using namespace std; class MemoryTracker { private: static int allocationCount; static int deallocationCount; public: // 重载全局new运算符 static void* operator new(size_t size) { allocationCount++; cout << "分配 " << size << " 字节内存 (总分配次数: " << allocationCount << ")" << endl; void* ptr = malloc(size); if (!ptr) { throw bad_alloc(); } return ptr; } // 重载全局delete运算符 static void operator delete(void* ptr) noexcept { deallocationCount++; cout << "释放内存 (总释放次数: " << deallocationCount << ")" << endl; free(ptr); } // 重载数组版本的new和delete static void* operator new[](size_t size) { allocationCount++; cout << "分配数组 " << size << " 字节内存 (总分配次数: " << allocationCount << ")" << endl; void* ptr = malloc(size); if (!ptr) { throw bad_alloc(); } return ptr; } static void operator delete[](void* ptr) noexcept { deallocationCount++; cout << "释放数组内存 (总释放次数: " << deallocationCount << ")" << endl; free(ptr); } static void printStats() { cout << "内存统计 - 分配: " << allocationCount << ", 释放: " << deallocationCount << endl; } }; // 静态成员初始化 int MemoryTracker::allocationCount = 0; int MemoryTracker::deallocationCount = 0; int main() { // 测试自定义内存管理 MemoryTracker* obj = new MemoryTracker(); delete obj; MemoryTracker* array = new MemoryTracker[3]; delete[] array; MemoryTracker::printStats(); return 0; }

4. 综合实战案例

4.1 动态字符串管理类

创建一个安全的字符串管理类：

#include <iostream> #include <cstring> #include <stdexcept> using namespace std; class SafeString { private: char* data; size_t length; // 辅助函数：分配内存并复制字符串 void allocateAndCopy(const char* str) { if (str == nullptr) { length = 0; data = new char[1]; data[0] = '\0'; } else { length = strlen(str); data = new char[length + 1]; strcpy(data, str); } } public: // 构造函数 SafeString(const char* str = nullptr) { allocateAndCopy(str); cout << "构造函数: " << (data ? data : "空字符串") << endl; } // 拷贝构造函数 SafeString(const SafeString& other) { allocateAndCopy(other.data); cout << "拷贝构造: " << data << endl; } // 移动构造函数（C++11） SafeString(SafeString&& other) noexcept : data(other.data), length(other.length) { other.data = nullptr; other.length = 0; cout << "移动构造" << endl; } // 赋值运算符 SafeString& operator=(const SafeString& other) { if (this != &other) { delete[] data; // 释放原有内存 allocateAndCopy(other.data); } cout << "赋值操作: " << data << endl; return *this; } // 移动赋值运算符（C++11） SafeString& operator=(SafeString&& other) noexcept { if (this != &other) { delete[] data; data = other.data; length = other.length; other.data = nullptr; other.length = 0; } cout << "移动赋值" << endl; return *this; } // 析构函数 ~SafeString() { cout << "析构函数: " << (data ? data : "空") << endl; delete[] data; } // 成员函数 size_t getLength() const { return length; } const char* c_str() const { return data ? data : ""; } // 连接字符串 SafeString operator+(const SafeString& other) const { size_t newLength = length + other.length; char* newData = new char[newLength + 1]; strcpy(newData, data); strcat(newData, other.data); SafeString result(newData); delete[] newData; return result; } // 下标操作符 char& operator[](size_t index) { if (index >= length) { throw out_of_range("索引超出范围"); } return data[index]; } const char& operator[](size_t index) const { if (index >= length) { throw out_of_range("索引超出范围"); } return data[index]; } }; // 测试SafeString类 int main() { cout << "=== SafeString 测试 ===" << endl; // 基本构造测试 SafeString str1("Hello"); SafeString str2(" World"); // 连接操作 SafeString str3 = str1 + str2; cout << "连接结果: " << str3.c_str() << endl; // 拷贝构造测试 SafeString str4 = str3; cout << "拷贝结果: " << str4.c_str() << endl; // 赋值操作测试 SafeString str5; str5 = str1; cout << "赋值结果: " << str5.c_str() << endl; // 下标操作测试 try { cout << "str3[0] = " << str3[0] << endl; str3[0] = 'h'; // 修改第一个字符 cout << "修改后: " << str3.c_str() << endl; // 测试越界访问 // cout << str3[100] << endl; // 会抛出异常 } catch (const exception& e) { cout << "异常捕获: " << e.what() << endl; } cout << "=== 测试结束 ===" << endl; return 0; }

4.2 智能指针模拟实现

理解智能指针的原理：

#include <iostream> #include <utility> using namespace std; // 简单的智能指针实现 template<typename T> class SimpleUniquePtr { private: T* ptr; public: // 构造函数 explicit SimpleUniquePtr(T* p = nullptr) : ptr(p) {} // 禁止拷贝构造和拷贝赋值 SimpleUniquePtr(const SimpleUniquePtr&) = delete; SimpleUniquePtr& operator=(const SimpleUniquePtr&) = delete; // 移动构造函数 SimpleUniquePtr(SimpleUniquePtr&& other) noexcept : ptr(other.ptr) { other.ptr = nullptr; } // 移动赋值运算符 SimpleUniquePtr& operator=(SimpleUniquePtr&& other) noexcept { if (this != &other) { delete ptr; ptr = other.ptr; other.ptr = nullptr; } return *this; } // 析构函数 ~SimpleUniquePtr() { delete ptr; } // 操作符重载 T& operator*() const { return *ptr; } T* operator->() const { return ptr; } explicit operator bool() const { return ptr != nullptr; } // 获取原始指针 T* get() const { return ptr; } // 释放所有权 T* release() { T* temp = ptr; ptr = nullptr; return temp; } // 重置指针 void reset(T* p = nullptr) { delete ptr; ptr = p; } }; // 测试智能指针 class TestObject { public: int value; TestObject(int v = 0) : value(v) { cout << "TestObject 构造函数: " << value << endl; } ~TestObject() { cout << "TestObject 析构函数: " << value << endl; } void display() { cout << "对象值: " << value << endl; } }; int main() { cout << "=== 智能指针测试 ===" << endl; { // 使用智能指针管理对象 SimpleUniquePtr<TestObject> ptr1(new TestObject(42)); ptr1->display(); // 移动语义测试 SimpleUniquePtr<TestObject> ptr2 = std::move(ptr1); if (!ptr1) { cout << "ptr1 已转移所有权" << endl; } ptr2->display(); // 自动内存管理测试 SimpleUniquePtr<TestObject> ptr3(new TestObject(100)); ptr3->display(); cout << "即将离开作用域..." << endl; } cout << "已离开作用域，对象自动销毁" << endl; return 0; }

5. 常见问题与解决方案

5.1 内存泄漏检测

内存泄漏是C++编程中的常见问题：

#include <iostream> #include <cstdlib> using namespace std; // 简单内存泄漏检测器 class MemoryLeakDetector { private: static int aliveObjects; public: MemoryLeakDetector() { aliveObjects++; cout << "对象创建，当前存活: " << aliveObjects << endl; } ~MemoryLeakDetector() { aliveObjects--; cout << "对象销毁，剩余存活: " << aliveObjects << endl; } static int getAliveCount() { return aliveObjects; } }; int MemoryLeakDetector::aliveObjects = 0; void testMemoryLeak() { MemoryLeakDetector* obj1 = new MemoryLeakDetector(); MemoryLeakDetector* obj2 = new MemoryLeakDetector(); // 故意造成内存泄漏 - 只删除一个对象 delete obj1; // obj2 没有被删除，造成内存泄漏 } int main() { cout << "=== 内存泄漏检测测试 ===" << endl; int initialCount = MemoryLeakDetector::getAliveCount(); cout << "初始对象数: " << initialCount << endl; testMemoryLeak(); int finalCount = MemoryLeakDetector::getAliveCount(); cout << "测试后对象数: " << finalCount << endl; if (finalCount > initialCount) { cout << "检测到内存泄漏！泄漏对象数: " << (finalCount - initialCount) << endl; } else { cout << "没有检测到内存泄漏" << endl; } return 0; }

5.2 悬空指针问题

悬空指针指向已释放的内存：

#include <iostream> using namespace std; void demonstrateDanglingPointer() { int* ptr = new int(100); cout << "分配内存，值: " << *ptr << endl; delete ptr; // 释放内存 // ptr现在成为悬空指针 cout << "已释放内存，ptr现在是悬空指针" << endl; // 以下行为是未定义的！ // cout << "悬空指针的值: " << *ptr << endl; // 危险！ // 正确的做法：释放后立即设置为nullptr ptr = nullptr; if (ptr != nullptr) { cout << "指针有效" << endl; } else { cout << "指针已设置为nullptr，安全" << endl; } } int main() { cout << "=== 悬空指针演示 ===" << endl; demonstrateDanglingPointer(); return 0; }

6. 最佳实践与工程建议

6.1 内存管理黄金法则

谁分配，谁释放：确保每个new都有对应的delete
使用RAII原则：资源获取即初始化，利用构造函数分配，析构函数释放
优先使用智能指针：在现代C++中，尽量使用unique_ptr、shared_ptr等
避免裸指针：除非必要，不要直接使用裸指针管理内存

6.2 代码规范建议

// 良好的内存管理实践示例 class GoodPracticeExample { private: int* data; size_t size; public: // 构造函数：分配资源 GoodPracticeExample(size_t s) : size(s), data(new int[s]) { // 初始化数据 for(size_t i = 0; i < size; i++) { data[i] = 0; } } // 拷贝构造函数：深拷贝 GoodPracticeExample(const GoodPracticeExample& other) : size(other.size), data(new int[other.size]) { copy(other.data, other.data + size, data); } // 移动构造函数：转移资源 GoodPracticeExample(GoodPracticeExample&& other) noexcept : size(other.size), data(other.data) { other.data = nullptr; other.size = 0; } // 赋值运算符 GoodPracticeExample& operator=(GoodPracticeExample other) { swap(*this, other); return *this; } // 友元swap函数 friend void swap(GoodPracticeExample& first, GoodPracticeExample& second) noexcept { using std::swap; swap(first.size, second.size); swap(first.data, second.data); } // 析构函数：释放资源 ~GoodPracticeExample() { delete[] data; } // 其他成员函数... };