C++ 通用指针void*和动态内存分配

梦想不会自己发光，真正闪耀的是那个为梦狂奔的你。献给知行的孩子们！（Eric.He著）

本教程将从 C++ 通用指针void*的特性、动态内存分配核心概念，到malloc、calloc、new三种动态内存分配方式的使用与区别，全面拆解动态内存管理的核心用法，帮助你掌握这一C++编程的关键技能。

教程目录导航

▼

一、核心概念概述

1.1 通用指针void* 核心定义与特性

void*（通用指针/无类型指针）是C/C++中的一种特殊指针类型，它可以指向任意数据类型的内存地址（int、char、结构体、类对象等），是实现通用内存操作的核心工具。

核心特性：

无类型特性：void* 仅记录内存地址，不关联具体数据类型，无法直接解引用（*）或进行指针算术运算；
万能兼容性：任何类型的指针都可以隐式转换为void*，无需强制类型转换；
类型安全：将void*转换回原类型指针时，必须显式强制类型转换，否则会编译报错；
常用场景：通用内存操作函数（如memcpy、memset）、跨类型内存管理、底层数据结构实现。

示例：void* 基本使用


#include <iostream>
#include <cstring>
using namespace std;

int main() {
    // 1. 基础类型指针转换为void*
    int num = 100;
    void* pVoid = #  // 隐式转换，无需强制类型转换
    
    // 2. void*转换回原类型指针（必须显式强转）
    int* pInt = (int*)pVoid;
    cout << "解引用void*转换后的指针：" << *pInt << endl;  // 输出：100
    
    // 3. void*指向不同类型数据
    char str[] = "Hello void*";
    pVoid = str;
    char* pChar = (char*)pVoid;
    cout << "void*指向字符串：" << pChar << endl;  // 输出：Hello void*
    
    // 4. 错误示例：void*无法直接解引用
    // cout << *pVoid;  // 编译报错：invalid use of void expression
    
    // 5. 错误示例：void*无法直接做指针算术运算
    // pVoid++;  // 编译报错：arithmetic on a pointer to void
    
    return 0;
}

1.2 动态内存分配概念与意义

动态内存分配是指程序运行时，从堆区（Heap）主动申请指定大小的内存空间，使用完毕后手动释放的内存管理方式（区别于栈区自动分配/释放的内存）。

核心意义：

内存灵活可控：可根据运行时需求（如用户输入、数据量变化）动态申请/释放内存，避免内存浪费；
延长内存生命周期：堆区内存不会随函数调用结束而销毁，可跨函数使用；
支持大规模数据存储：栈区空间有限（通常几MB），堆区可分配GB级别的内存，适合存储大数组、复杂对象等。

内存分区对比：

内存区域	分配方式	释放方式	生命周期	空间大小
栈区（Stack）	编译器自动分配	编译器自动释放	函数调用结束销毁	较小（MB级）
堆区（Heap）	手动调用函数/关键字分配	手动调用函数/关键字释放	直到手动释放或程序结束	较大（GB级）

二、动态内存分配的三种核心方式

2.1 malloc 动态内存分配

malloc是C语言标准库函数，用于从堆区分配指定字节数的内存空间，返回void*类型指针（需强制转换为目标类型），分配的内存未初始化（内容为随机值）。

语法格式：


#include   // 必须包含头文件
void* malloc(size_t size);  // size：需要分配的字节数

核心要点：

返回值：成功分配返回内存起始地址（void*），失败返回NULL；
内存初始化：分配的内存未清零，内容为随机垃圾值；
释放方式：需调用free()函数释放，否则内存泄漏；
字节数计算：通常结合sizeof()计算（如malloc(sizeof(int)*5)）。

示例：malloc 使用完整流程


#include <iostream>
#include <cstdlib>  // malloc/free头文件
using namespace std;

int main() {
    // 1. 分配能存储5个int类型的内存空间
    int* pArr = (int*)malloc(sizeof(int) * 5);
    
    // 2. 检查内存分配是否成功
    if (pArr == NULL) {
        cout << "内存分配失败！" << endl;
        return -1;
    }
    
    // 3. 初始化并使用内存（malloc分配的内存未初始化）
    for (int i = 0; i < 5; i++) {
        pArr[i] = i + 1;  // 手动赋值：1,2,3,4,5
        cout << "pArr[" << i << "] = " << pArr[i] << endl;
    }
    
    // 4. 释放内存（必须手动释放）
    free(pArr);
    pArr = nullptr;  // 避免野指针
    
    return 0;
}

2.2 calloc 动态内存分配

calloc是C语言标准库函数，与malloc功能类似，但会将分配的内存全部初始化为0，适合需要初始化为零的场景。

语法格式：


#include   // 必须包含头文件
void* calloc(size_t num, size_t size);  
// num：元素个数；size：每个元素的字节数

核心要点：

返回值：成功返回内存起始地址（void*），失败返回NULL；
内存初始化：分配的内存自动清零（所有字节为0）；
释放方式：同样需调用free()函数释放；
总字节数：num * size（如calloc(5, sizeof(int)) = 5个int的字节数）。

示例：calloc 使用完整流程


#include <iostream>
#include <cstdlib>
using namespace std;

int main() {
    // 1. 分配5个int类型的内存空间，且自动初始化为0
    int* pArr = (int*)calloc(5, sizeof(int));
    
    // 2. 检查分配结果
    if (pArr == NULL) {
        cout << "内存分配失败！" << endl;
        return -1;
    }
    
    // 3. 验证内存已初始化为0
    cout << "calloc分配的内存初始值：" << endl;
    for (int i = 0; i < 5; i++) {
        cout << "pArr[" << i << "] = " << pArr[i] << endl;  // 全部输出0
    }
    
    // 4. 赋值并使用
    pArr[0] = 10;
    pArr[1] = 20;
    cout << "\n赋值后：" << endl;
    cout << "pArr[0] = " << pArr[0] << ", pArr[1] = " << pArr[1] << endl;
    
    // 5. 释放内存
    free(pArr);
    pArr = nullptr;
    
    return 0;
}

2.3 new 动态内存分配（C++专属）

new是C++关键字（非函数），专为C++设计的动态内存分配方式，支持类型安全、自动调用构造函数，是C++中推荐的动态内存分配方式。

语法格式：


// 1. 单个对象分配
类型* 指针变量 = new 类型;          // 无参构造初始化
类型* 指针变量 = new 类型(初始化值);  // 有参构造初始化

// 2. 数组分配
类型* 指针变量 = new 类型[元素个数];

// 3. 释放内存
delete 指针变量;        // 释放单个对象
delete[] 指针变量;      // 释放数组

核心要点：

类型安全：无需强制类型转换（返回对应类型指针）；
初始化特性：分配类/结构体对象时，自动调用构造函数；
错误处理：分配失败时抛出bad_alloc异常（而非返回NULL）；
释放方式：单个对象用delete，数组用delete[]（必须匹配）。

示例1：基本类型的new/delete


#include <iostream>
#include <new>  // 异常处理头文件
using namespace std;

int main() {
    try {
        // 1. 单个int类型内存分配（可直接初始化）
        int* pNum = new int(100);
        cout << "new分配的int值：" << *pNum << endl;  // 输出：100
        
        // 2. 数组内存分配
        int* pArr = new int[5]{1,2,3,4,5};  // C++11及以上支持直接初始化
        cout << "\nnew分配的数组：" << endl;
        for (int i = 0; i < 5; i++) {
            cout << "pArr[" << i << "] = " << pArr[i] << endl;
        }
        
        // 3. 释放内存
        delete pNum;    // 释放单个对象
        delete[] pArr;  // 释放数组
        pNum = nullptr;
        pArr = nullptr;
        
    } catch (bad_alloc& e) {
        // 捕获内存分配失败异常
        cout << "内存分配失败：" << e.what() << endl;
        return -1;
    }
    
    return 0;
}

示例2：结构体/类对象的new/delete（自动调用构造/析构函数）


#include <iostream>
#include <cstring>
using namespace std;

// 定义结构体
struct Student {
    char name[20];
    int age;
    
    // 构造函数
    Student() {
        strcpy(name, "未知");
        age = 0;
        cout << "无参构造函数调用" << endl;
    }
    
    Student(const char* n, int a) {
        strcpy(name, n);
        age = a;
        cout << "有参构造函数调用" << endl;
    }
    
    // 析构函数
    ~Student() {
        cout << "析构函数调用：释放" << name << "的内存" << endl;
    }
};

int main() {
    // 1. 单个结构体对象分配
    Student* pStu = new Student("张三", 18);
    cout << "学生姓名：" << pStu->name << "，年龄：" << pStu->age << endl;
    
    // 2. 释放对象（自动调用析构函数）
    delete pStu;
    pStu = nullptr;
    
    // 3. 结构体数组分配
    Student* pStuArr = new Student[2]{Student("李四", 19), Student("王五", 20)};
    delete[] pStuArr;  // 释放数组，自动调用每个元素的析构函数
    
    return 0;
}

三、malloc/calloc/new 的关键区别

特性	malloc	calloc	new
本质	C库函数	C库函数	C++关键字
返回值	void*（需强制类型转换）	void*（需强制类型转换）	对应类型指针（无需转换）
内存初始化	未初始化（随机值）	自动初始化为0	可直接初始化（类/结构体调用构造函数）
参数形式	单个参数（总字节数）	两个参数（元素个数+单个元素字节数）	类型+可选初始化值/数组长度
失败处理	返回NULL	返回NULL	抛出bad_alloc异常（默认）
面向对象支持	不支持（仅分配内存，不调用构造/析构）	不支持（仅分配内存，不调用构造/析构）	支持（自动调用构造/析构函数）
释放方式	free()	free()	delete（单个对象）/delete[]（数组）
适用场景	C/C++通用，无需初始化的内存分配	C/C++通用，需要初始化为0的内存分配	C++专属，尤其是类/结构体对象分配

四、注意事项

内存泄漏防范：动态分配的内存必须手动释放（free/delete/delete[]），且释放后需将指针置为nullptr，避免野指针；
释放方式匹配：malloc/calloc分配的内存只能用free释放，new分配的单个对象用delete，new[]分配的数组用delete[]，混用会导致未定义行为；
void* 安全使用：将void*转换回原类型时，必须确保类型匹配，否则会导致内存访问错误；
new的异常处理：使用new时建议捕获bad_alloc异常，避免程序直接崩溃；
calloc性能损耗：calloc因自动初始化内存，性能略低于malloc，无需清零时优先使用malloc；
堆区内存大小：动态内存分配并非无限制，分配过大内存会失败，需合理规划内存使用；
避免重复释放：同一内存地址不能多次释放，否则会触发程序崩溃。

五、总结

void* 是通用无类型指针，可指向任意类型内存，需显式转换才能解引用，是通用内存操作的核心工具；
动态内存分配从堆区申请内存，生命周期由程序员控制，核心方式包括malloc（未初始化）、calloc（初始化为0）、new（C++专属，支持构造函数）；
malloc/calloc是C库函数，返回void*，需用free释放；new是C++关键字，返回类型安全指针，需用delete/delete[]释放；
calloc与malloc的核心区别是自动清零，new与前两者的核心区别是支持面向对象特性（构造/析构函数）；
动态内存管理的核心是“申请-使用-释放”闭环，需防范内存泄漏、野指针、重复释放等问题。

本教程从通用指针void*到三种动态内存分配方式，全面拆解了C++动态内存管理的核心知识点。掌握动态内存分配与释放，是编写高效、稳定C++程序的必备技能，尤其在数据结构（链表、栈、队列等）实现中不可或缺。

返回顶部