动态内存分配终极指南：malloc、free的20种正确打开方式

原创 于 2025-07-08 09:18:47 发布 · 890 阅读 · 24 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c

🎓博主介绍：精通 C、Python、Java、JavaScript 等编程语言，具备全栈开发能力。日常专注于分享编程干货、算法解析、项目实战经验，以及前沿技术动态。让我们一起在技术的道路上不断探索，共同成长！
在这里插入图片描述

动态内存分配终极指南：malloc、free的20种正确打开方式

一、引言

在C语言编程中，动态内存分配是一项至关重要的技术，它允许程序在运行时灵活地分配和释放内存。malloc 和 free 作为实现动态内存分配和释放的核心函数，其正确使用与否直接关系到程序的性能和稳定性。本文将详细介绍 malloc 和 free 的20种正确打开方式，帮助技术人员深入理解并熟练运用动态内存分配。

二、malloc和free基础

（一）malloc函数概述

malloc 函数用于在堆上分配指定大小的内存块，其原型如下：

void* malloc(size_t size);

其中，size 是需要分配的内存字节数。如果分配成功，malloc 返回一个指向分配内存块起始地址的指针；如果分配失败，返回 NULL。

（二）free函数概述

free 函数用于释放之前通过 malloc、calloc 或 realloc 分配的内存块，其原型如下：

void free(void* ptr);

其中，ptr 是指向需要释放的内存块起始地址的指针。

（三）基本使用示例

#include <stdio.h>
#include <stdlib.h>

int main() {
    // 分配一个整数大小的内存块
    int* numPtr = (int*)malloc(sizeof(int));
    if (numPtr != NULL) {
        // 给分配的内存赋值
        *numPtr = 42;
        printf("分配的整数为: %d\n", *numPtr);
        // 释放内存
        free(numPtr);
    }
    return 0;
}

三、malloc和free的20种正确打开方式

（一）分配单个变量内存

#include <stdio.h>
#include <stdlib.h>

int main() {
    double* doublePtr = (double*)malloc(sizeof(double));
    if (doublePtr != NULL) {
        *doublePtr = 3.14;
        printf("分配的双精度浮点数为: %f\n", *doublePtr);
        free(doublePtr);
    }
    return 0;
}

（二）分配数组内存

#include <stdio.h>
#include <stdlib.h>

int main() {
    int size = 5;
    int* arr = (int*)malloc(size * sizeof(int));
    if (arr != NULL) {
        for (int i = 0; i < size; i++) {
            arr[i] = i;
        }
        for (int i = 0; i < size; i++) {
            printf("%d ", arr[i]);
        }
        printf("\n");
        free(arr);
    }
    return 0;
}

（三）分配多维数组内存

#include <stdio.h>
#include <stdlib.h>

#define ROWS 3
#define COLS 4

int main() {
    int** matrix = (int**)malloc(ROWS * sizeof(int*));
    if (matrix != NULL) {
        for (int i = 0; i < ROWS; i++) {
            matrix[i] = (int*)malloc(COLS * sizeof(int));
            if (matrix[i] == NULL) {
                // 处理内存分配失败情况
                for (int j = 0; j < i; j++) {
                    free(matrix[j]);
                }
                free(matrix);
                return 1;
            }
        }
        // 初始化矩阵
        for (int i = 0; i < ROWS; i++) {
            for (int j = 0; j < COLS; j++) {
                matrix[i][j] = i * COLS + j;
            }
        }
        // 输出矩阵
        for (int i = 0; i < ROWS; i++) {
            for (int j = 0; j < COLS; j++) {
                printf("%d ", matrix[i][j]);
            }
            printf("\n");
        }
        // 释放内存
        for (int i = 0; i < ROWS; i++) {
            free(matrix[i]);
        }
        free(matrix);
    }
    return 0;
}

（四）动态调整字符串长度

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
    char* str = (char*)malloc(10 * sizeof(char));
    if (str != NULL) {
        strcpy(str, "Hello");
        // 重新分配更大的内存
        char* newStr = (char*)realloc(str, 20 * sizeof(char));
        if (newStr != NULL) {
            str = newStr;
            strcat(str, ", World!");
            printf("新字符串为: %s\n", str);
            free(str);
        } else {
            free(str);
        }
    }
    return 0;
}

（五）分配结构体数组内存

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int id;
    char name[20];
} Person;

int main() {
    int size = 3;
    Person* people = (Person*)malloc(size * sizeof(Person));
    if (people != NULL) {
        for (int i = 0; i < size; i++) {
            people[i].id = i;
            sprintf(people[i].name, "Person%d", i);
        }
        for (int i = 0; i < size; i++) {
            printf("ID: %d, Name: %s\n", people[i].id, people[i].name);
        }
        free(people);
    }
    return 0;
}

（六）在函数中分配内存并返回指针

#include <stdio.h>
#include <stdlib.h>

int* createArray(int size) {
    int* arr = (int*)malloc(size * sizeof(int));
    if (arr != NULL) {
        for (int i = 0; i < size; i++) {
            arr[i] = i;
        }
    }
    return arr;
}

int main() {
    int size = 5;
    int* arr = createArray(size);
    if (arr != NULL) {
        for (int i = 0; i < size; i++) {
            printf("%d ", arr[i]);
        }
        printf("\n");
        free(arr);
    }
    return 0;
}

（七）使用calloc初始化内存

#include <stdio.h>
#include <stdlib.h>

int main() {
    int size = 5;
    int* arr = (int*)calloc(size, sizeof(int));
    if (arr != NULL) {
        for (int i = 0; i < size; i++) {
            printf("%d ", arr[i]);
        }
        printf("\n");
        free(arr);
    }
    return 0;
}

（八）检查malloc返回值

#include <stdio.h>
#include <stdlib.h>

int main() {
    int* largeArr = (int*)malloc(1000000000 * sizeof(int));
    if (largeArr == NULL) {
        printf("内存分配失败\n");
    } else {
        // 使用内存
        free(largeArr);
    }
    return 0;
}

（九）多次分配和释放内存

#include <stdio.h>
#include <stdlib.h>

int main() {
    for (int i = 0; i < 5; i++) {
        int* numPtr = (int*)malloc(sizeof(int));
        if (numPtr != NULL) {
            *numPtr = i;
            printf("第 %d 次分配的整数为: %d\n", i, *numPtr);
            free(numPtr);
        }
    }
    return 0;
}

（十）释放部分动态分配的内存

#include <stdio.h>
#include <stdlib.h>

#define SIZE 10

int main() {
    int* arr = (int*)malloc(SIZE * sizeof(int));
    if (arr != NULL) {
        for (int i = 0; i < SIZE; i++) {
            arr[i] = i;
        }
        // 释放前半部分内存
        int halfSize = SIZE / 2;
        int* newArr = (int*)realloc(arr, halfSize * sizeof(int));
        if (newArr != NULL) {
            arr = newArr;
            for (int i = 0; i < halfSize; i++) {
                printf("%d ", arr[i]);
            }
            printf("\n");
            free(arr);
        }
    }
    return 0;
}

（十一）分配内存用于存储函数指针

#include <stdio.h>
#include <stdlib.h>

typedef int (*FuncPtr)(int, int);

int add(int a, int b) {
    return a + b;
}

int main() {
    FuncPtr* funcArr = (FuncPtr*)malloc(1 * sizeof(FuncPtr));
    if (funcArr != NULL) {
        funcArr[0] = add;
        int result = funcArr[0](3, 4);
        printf("函数调用结果: %d\n", result);
        free(funcArr);
    }
    return 0;
}

（十二）使用动态内存分配实现栈

#include <stdio.h>
#include <stdlib.h>

#define STACK_SIZE 10

typedef struct {
    int* data;
    int top;
} Stack;

Stack* createStack() {
    Stack* stack = (Stack*)malloc(sizeof(Stack));
    if (stack != NULL) {
        stack->data = (int*)malloc(STACK_SIZE * sizeof(int));
        if (stack->data != NULL) {
            stack->top = -1;
        } else {
            free(stack);
            stack = NULL;
        }
    }
    return stack;
}

void push(Stack* stack, int value) {
    if (stack->top < STACK_SIZE - 1) {
        stack->data[++(stack->top)] = value;
    }
}

int pop(Stack* stack) {
    if (stack->top >= 0) {
        return stack->data[(stack->top)--];
    }
    return -1;
}

void freeStack(Stack* stack) {
    if (stack != NULL) {
        free(stack->data);
        free(stack);
    }
}

int main() {
    Stack* stack = createStack();
    if (stack != NULL) {
        push(stack, 1);
        push(stack, 2);
        printf("弹出元素: %d\n", pop(stack));
        freeStack(stack);
    }
    return 0;
}

（十三）分配内存用于存储链表节点

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int data;
    struct Node* next;
} Node;

Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (newNode != NULL) {
        newNode->data = data;
        newNode->next = NULL;
    }
    return newNode;
}

void freeList(Node* head) {
    Node* temp;
    while (head != NULL) {
        temp = head;
        head = head->next;
        free(temp);
    }
}

int main() {
    Node* head = createNode(1);
    head->next = createNode(2);
    Node* current = head;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
    freeList(head);
    return 0;
}

（十四）动态分配内存用于存储二叉树节点

#include <stdio.h>
#include <stdlib.h>

typedef struct TreeNode {
    int data;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;

TreeNode* createTreeNode(int data) {
    TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));
    if (newNode != NULL) {
        newNode->data = data;
        newNode->left = NULL;
        newNode->right = NULL;
    }
    return newNode;
}

void freeTree(TreeNode* root) {
    if (root != NULL) {
        freeTree(root->left);
        freeTree(root->right);
        free(root);
    }
}

int main() {
    TreeNode* root = createTreeNode(1);
    root->left = createTreeNode(2);
    root->right = createTreeNode(3);
    freeTree(root);
    return 0;
}

（十五）使用动态内存分配实现动态数组

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int* data;
    int size;
    int capacity;
} DynamicArray;

DynamicArray* createDynamicArray() {
    DynamicArray* arr = (DynamicArray*)malloc(sizeof(DynamicArray));
    if (arr != NULL) {
        arr->data = (int*)malloc(1 * sizeof(int));
        if (arr->data != NULL) {
            arr->size = 0;
            arr->capacity = 1;
        } else {
            free(arr);
            arr = NULL;
        }
    }
    return arr;
}

void append(DynamicArray* arr, int value) {
    if (arr->size == arr->capacity) {
        arr->capacity *= 2;
        arr->data = (int*)realloc(arr->data, arr->capacity * sizeof(int));
    }
    arr->data[arr->size++] = value;
}

void freeDynamicArray(DynamicArray* arr) {
    if (arr != NULL) {
        free(arr->data);
        free(arr);
    }
}

int main() {
    DynamicArray* arr = createDynamicArray();
    if (arr != NULL) {
        append(arr, 1);
        append(arr, 2);
        for (int i = 0; i < arr->size; i++) {
            printf("%d ", arr->data[i]);
        }
        printf("\n");
        freeDynamicArray(arr);
    }
    return 0;
}

（十六）在循环中动态分配和释放内存

#include <stdio.h>
#include <stdlib.h>

int main() {
    for (int i = 0; i < 3; i++) {
        char* str = (char*)malloc(10 * sizeof(char));
        if (str != NULL) {
            sprintf(str, "Str%d", i);
            printf("分配的字符串: %s\n", str);
            free(str);
        }
    }
    return 0;
}

（十七）分配内存用于存储文件内容

#include <stdio.h>
#include <stdlib.h>

#define BUFFER_SIZE 100

int main() {
    FILE* file = fopen("test.txt", "r");
    if (file != NULL) {
        char* buffer = (char*)malloc(BUFFER_SIZE * sizeof(char));
        if (buffer != NULL) {
            while (fgets(buffer, BUFFER_SIZE, file) != NULL) {
                printf("%s", buffer);
            }
            free(buffer);
        }
        fclose(file);
    }
    return 0;
}

（十八）使用动态内存分配实现队列（续）


        enqueue(queue, 2);

        printf("出队元素: %d\n", dequeue(queue));

        freeQueue(queue);

    }

    return 0;

}

在这个队列实现中，createQueue 函数使用 malloc 为队列结构体和队列数据数组分配内存。enqueue 函数用于向队列中添加元素，dequeue 函数用于从队列中移除元素，freeQueue 函数用于释放队列所占用的内存。

（十九）动态分配内存实现环形缓冲区

#include <stdio.h>
#include <stdlib.h>

#define BUFFER_SIZE 5

typedef struct {
    int* data;
    int head;
    int tail;
    int size;
} CircularBuffer;

CircularBuffer* createCircularBuffer() {
    CircularBuffer* buffer = (CircularBuffer*)malloc(sizeof(CircularBuffer));
    if (buffer != NULL) {
        buffer->data = (int*)malloc(BUFFER_SIZE * sizeof(int));
        if (buffer->data != NULL) {
            buffer->head = 0;
            buffer->tail = 0;
            buffer->size = 0;
        } else {
            free(buffer);
            buffer = NULL;
        }
    }
    return buffer;
}

void insert(CircularBuffer* buffer, int value) {
    if (buffer->size < BUFFER_SIZE) {
        buffer->data[buffer->tail] = value;
        buffer->tail = (buffer->tail + 1) % BUFFER_SIZE;
        buffer->size++;
    }
}

int removeElement(CircularBuffer* buffer) {
    if (buffer->size > 0) {
        int value = buffer->data[buffer->head];
        buffer->head = (buffer->head + 1) % BUFFER_SIZE;
        buffer->size--;
        return value;
    }
    return -1;
}

void freeCircularBuffer(CircularBuffer* buffer) {
    if (buffer != NULL) {
        free(buffer->data);
        free(buffer);
    }
}

int main() {
    CircularBuffer* buffer = createCircularBuffer();
    if (buffer != NULL) {
        insert(buffer, 1);
        insert(buffer, 2);
        printf("移除元素: %d\n", removeElement(buffer));
        freeCircularBuffer(buffer);
    }
    return 0;
}

环形缓冲区是一种常用的数据结构，通过动态内存分配可以灵活地创建和管理。createCircularBuffer 函数分配内存并初始化缓冲区，insert 函数用于插入元素，removeElement 函数用于移除元素，freeCircularBuffer 函数用于释放内存。

（二十）根据用户输入动态分配内存

#include <stdio.h>
#include <stdlib.h>

int main() {
    int size;
    printf("请输入要分配的数组大小: ");
    scanf("%d", &size);

    int* arr = (int*)malloc(size * sizeof(int));
    if (arr != NULL) {
        for (int i = 0; i < size; i++) {
            arr[i] = i;
        }
        for (int i = 0; i < size; i++) {
            printf("%d ", arr[i]);
        }
        printf("\n");
        free(arr);
    }
    return 0;
}

在这个示例中，程序根据用户输入的大小动态分配数组内存。用户可以根据实际需求决定数组的大小，然后使用 malloc 分配相应的内存，使用完后使用 free 释放内存。

四、动态内存分配的注意事项

（一）内存泄漏

在使用 malloc 分配内存后，必须确保在不再使用时调用 free 释放内存，否则会导致内存泄漏。例如：

#include <stdio.h>
#include <stdlib.h>

int main() {
    int* ptr = (int*)malloc(sizeof(int));
    // 忘记释放内存
    return 0;
}

在这个示例中，ptr 指向的内存没有被释放，会造成内存泄漏。

（二）悬空指针

当使用 free 释放内存后，指向该内存的指针会变成悬空指针。如果后续继续使用该指针，会导致未定义行为。例如：

#include <stdio.h>
#include <stdlib.h>

int main() {
    int* ptr = (int*)malloc(sizeof(int));
    *ptr = 10;
    free(ptr);
    // 悬空指针使用
    printf("%d\n", *ptr);
    return 0;
}

为了避免悬空指针问题，在释放内存后可以将指针置为 NULL，如 ptr = NULL;。

（三）多次释放

不要对同一块内存多次调用 free，这会导致未定义行为。例如：

#include <stdio.h>
#include <stdlib.h>

int main() {
    int* ptr = (int*)malloc(sizeof(int));
    free(ptr);
    // 多次释放
    free(ptr);
    return 0;
}

（四）内存越界访问

在使用动态分配的内存时，要确保不会越界访问。例如：

#include <stdio.h>
#include <stdlib.h>

int main() {
    int* arr = (int*)malloc(5 * sizeof(int));
    // 越界访问
    arr[10] = 10;
    free(arr);
    return 0;
}

越界访问可能会破坏其他内存区域的数据，导致程序崩溃或产生不可预期的结果。

五、总结

动态内存分配是 C 语言中一项强大而灵活的特性，malloc 和 free 函数是实现动态内存分配和释放的核心工具。通过本文介绍的 20 种正确打开方式，你可以深入了解如何在不同场景下正确使用 malloc 和 free，同时要注意避免内存泄漏、悬空指针、多次释放和内存越界访问等问题。掌握动态内存分配技术，将使你的 C 语言编程能力得到显著提升。

放内存后可以将指针置为 NULL，如 ptr = NULL;。

（三）多次释放

不要对同一块内存多次调用 free，这会导致未定义行为。例如：

#include <stdio.h>
#include <stdlib.h>

int main() {
    int* ptr = (int*)malloc(sizeof(int));
    free(ptr);
    // 多次释放
    free(ptr);
    return 0;
}

（四）内存越界访问

在使用动态分配的内存时，要确保不会越界访问。例如：

#include <stdio.h>
#include <stdlib.h>

int main() {
    int* arr = (int*)malloc(5 * sizeof(int));
    // 越界访问
    arr[10] = 10;
    free(arr);
    return 0;
}

越界访问可能会破坏其他内存区域的数据，导致程序崩溃或产生不可预期的结果。

五、总结

动态内存分配是 C 语言中一项强大而灵活的特性，malloc 和 free 函数是实现动态内存分配和释放的核心工具。通过本文介绍的 20 种正确打开方式，你可以深入了解如何在不同场景下正确使用 malloc 和 free，同时要注意避免内存泄漏、悬空指针、多次释放和内存越界访问等问题。掌握动态内存分配技术，将使你的 C 语言编程能力得到显著提升。

undefined
undefined
undefined
undefined
undefined
undefined
undefined

malloc、calloc、realloc函数
qq_19926581的博客
07-24 290
malloc、calloc、realloc函数
malloc（）函数与free（）函数的使用
Kokomi_的博客
11-13 7882
引入
malloc函数用法
Code Writers
01-08 8351
malloc函数是一种分配长度为num_bytes字节的内存块的函数，可以向系统申请分配指定size个字节的内存空间。malloc的全称是memory allocation（动态内存分配），当无法知道内存具体位置的时候，想要绑定真正的内存空间，就需要用到动态的分配内存。返回类型是void∗类型。void∗表示未确定类型的指针。C,C++规定，void∗类型可以通过类型转换强制转换为任何其它类型的指针。
c 从语言中的内存管理
weixin_34025051的博客
04-16 348
在C里，内存管理是通过专门的函数来实现。另外，为了兼容各种编程语言，操作系统提供的接口通常是 C 语言写成的函数声明（Windows 本身也由C和汇编语言写成）。 1 分配内存 malloc 函数 需要包含头文件：   &lt;stdlib.h&gt;   and   &lt;malloc.h&gt; 函数声明(函数原型) void *malloc(int size); 说明：mall...
malloc 和 free - C
weixin_34186931的博客
09-21 218
内存管理 在C里，内存管理是通过专门的函数来实现。另外，为了兼容各种编程语言，操作系统提供的接口通常是 C 语言写成的函数声明 （Windows 本身也由C和汇编语言写成）。 1 分配内存 malloc 函数 需要包含头文件： #include "stdlib.h" 函数声明(...
题外话：谈谈malloc()和free()
Jensyn' blog
05-18 1478
http://www.nowamagic.net/librarys/veda/detail/1807   对于串的顺序存储，有些需要补充说明。串值的存储空间可在程序执行过程中动态分配而得。比如在计算机中存在一个自由存储区，叫做“堆”。这个堆可由C语言的动态分配函数malloc()和free()来管理。 那么今天就来点题外话，谈谈malloc()和free() malloc()和free()
关于malloc和free函数的用法
以现在的努力程度之低，谈狗屁的未来，屎的梦想！！！
10-15 1068
在C语言的学习中，对内存管理这部分的知识掌握尤其重要！之前对C中的malloc()和free()两个函数的了解甚少，只知道大概该怎么用—— 就是malloc然后free就一切OK了。当然现在对这两个函数的体会也不见得多，不过对于本文章第三部分的内容倒是有了转折性的认识，所以
C语言动态内存分配终极指南：从入门到精通的20个实用技巧
[C语言动态内存分配终极指南：从入门到精通的20个实用技巧](https://i1.wp.com/coder-tronics.com/wp-content/uploads/2014/02/Anatomy-of-a-C-function.png) # 1. C语言动态内存分配基础 ## 1.1 动态内存分配概念 ...
内存管理终极指南：单片机动态内存分配函数与资源优化
本文首先对内存管理的基础概念进行了解析，随后深入探讨了单片机的动态内存管理机制，包括动态内存分配的原理、内存管理函数的使用及内存泄漏和越界问题的防范。第三章提出了内存分配实践与优化策略，如内存碎片处理...
LWIP内存管理终极指南：防止系统崩溃的关键技术与实践
本文首先概述了LWIP内存管理的基本概念和特点，随后深入探讨了其内存分配机制的理论基础，包括内存分配策略、内存管理器结构、内存泄漏和碎片问题。通过实践章节，本文分析了内存分配与释放的API使用、内存池的配置...
IMX485LQJ-C内存管理终极指南：减少泄漏，提升性能
[IMX485LQJ-C内存管理终极指南：减少泄漏，提升性能](https://media.geeksforgeeks.org/wp-content/uploads/20191202231341/shared_ptr.png) # 摘要 本文针对IMX485LQJ-C内存管理系统进行了全面的分析和探讨。首先...
内存管理不再难：C语言动态分配与泄漏防范终极指南！
本文系统地介绍了C语言内存管理的基础知识，详细探讨了动态内存分配的原理和常见错误，以及指针与动态数组的应用。文章还对内存泄漏的识别与防范提供了深入分析，并介绍了内存模型对程序优化的潜在影响。最后，文章...
malloc和free的用法
2302_76572476的博客
03-19 619
函数： void * memset(void *s, int c, size_t n);返回值：如果申请成功，则会返回申请到的空间的首地址，如果申请失败，则返回NULL。函数： void bzero(void *s, size_t n);函数： void *malloc(size_t size);参数：你要释放的空间的首地址，也就是mallo的返回值！参数：申请的内存空间的大小（字节）在本文中主要用来填充0：清空的作用。参数3：填充的内存空间的大小。参数1：填充的空间的首地址。参数1：清空的空间的首地址。
C语言中malloc和free的用法
四月天的专栏
04-29 2696
      在C里，内存管理是通过专门的函数来实现。另外，为了兼容各种编程语言，操作系统提供的接口通常是C语言写成的函数声明(Windows 本身也由C和汇编语言写成)。 包含的头文件为：   and         1.分配内存malloc函数 需要包含头文件：#include  函数声明(函数原型)：void *malloc(int size); 说明：mal
malloc与free函数的用法(精简全面 · 一看即懂)
最新发布
m0_74475605的博客
07-12 2447
malloc与free函数知识点及使用方法
malloc和free函数的用法
chengnian7642的博客
08-11 882
本文只有部分内容，请到一牛网阅读全文： http://www.16rd.com/blog-8517-927.html 在C语言的学习中，对内存管理这部分的知识掌握尤其重要！之前对C中的malloc()和free()两个函数的了解甚少，只知道大概该怎么用——就是 malloc然后free就一切O...
关于malloc和free函数的用法(发表…
好好工作，好好生活，
03-25 662
关于malloc和free函数的用法(发表时间: 2008-3-22 19:45:00) <a rel="nofollow" href= "http://blog.pfan.cn/vfdff/33507.html#comment">【评论】 【打印】 【字体：<a rel= "nofollow" href="">大 中 小】 本文链接：<a rel= "nofollow" href= "http:
malloc()与free()的简单使用
qq_52046856的博客
04-15 591
malloc()的使用 设计一个数据结构程序的过程是 //先定义所需要的变量与指针变量---->进行内存分配 ---->判断是否分配成功(分配不成功就报错或者退出程序) ---->对指针空间中的数据进行操作(如赋值，修改，查询，删除) ---->完成操作后释放指针 # malloc()与free()的简单使用 #include<stdio.h> #include<stdlib.h> int main() { int *p; //定义一个指向整形..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值