【C语言】内存管理函数详细讲解

于 2024-08-13 23:25:22 发布
阅读量829 收藏 9
点赞数 20
分类专栏： C语言 文章标签： c语言 c++ malloc calloc realloc free
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/EleganceJiaBao/article/details/141176315
版权

LuckiBit

目录

1. C语言内存管理函数详细讲解

在C语言编程中，内存管理是至关重要的。动态内存分配函数允许程序在运行时请求和释放内存，这对于处理不确定大小的数据结构至关重要。以下是C语言内存管理函数的详细讲解，包括每个函数的功能、标准格式、示例代码、代码解释及其输出。

1.1 malloc

功能: malloc 函数用于动态分配指定字节数的内存块。分配的内存块的内容未被初始化，因此其初始值是不确定的。

标准格式:

void *malloc(size_t size);

参数:

  • size: 需要分配的内存块的大小（以字节为单位）。

返回值:

  • 如果分配成功，malloc 返回指向分配内存块的指针。否则，返回 NULL。

示例代码:

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

int main() {
    // 分配内存用于存储5个int类型的值
    int *arr = (int *)malloc(5 * sizeof(int));

    // 检查内存是否分配成功
    if (arr != NULL) {
        // 初始化数组元素
        for (int i = 0; i < 5; i++) {
            arr[i] = i + 1;
        }

        // 输出数组元素
        printf("Array contents after malloc: ");
        for (int i = 0; i < 5; i++) {
            printf("%d ", arr[i]);
        }
        printf("\n");

        // 释放内存
        free(arr);
    } else {
        printf("Memory allocation failed!\n");
    }

    return 0;
}

代码解释:

  • malloc(5 * sizeof(int))：分配了足够存储5个 int 类型值的内存。sizeof(int) 获取 int 类型的字节数，因此 5 * sizeof(int) 是需要的总字节数。
  • if (arr != NULL)：检查内存分配是否成功。malloc 可能会失败，特别是在内存不足时，因此需要检查返回值。
  • 使用 for 循环初始化数组元素，并使用 printf 输出数组内容。
  • 使用 free(arr) 释放动态分配的内存，避免内存泄漏。

输出结果:

Array contents after malloc: 1 2 3 4 5

应用场景:

  • 当需要处理不确定数量的数据时，例如用户输入的数据、动态生成的数组等，malloc 非常有用。

1.2 calloc

功能: calloc 函数用于动态分配内存并将其初始化为零。它特别适合用于分配数组。

标准格式:

void *calloc(size_t nmemb, size_t size);

参数:

  • nmemb: 数组中的元素数量。
  • size: 每个元素的大小（以字节为单位）。

返回值:

  • 如果分配成功，calloc 返回指向分配内存块的指针，并将所有字节初始化为零。否则，返回 NULL。

示例代码:

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

int main() {
    int num_students;

    printf("Enter the number of students: ");
    scanf("%d", &num_students);

    // 动态分配内存并初始化为零
    int *grades = (int *)calloc(num_students, sizeof(int));

    // 检查内存是否分配成功
    if (grades != NULL) {
        printf("Initial grades (all should be 0):\n");
        for (int i = 0; i < num_students; i++) {
            printf("Student %d: %d\n", i + 1, grades[i]);
        }

        // 修改成绩并输出
        printf("Enter grades for each student:\n");
        for (int i = 0; i < num_students; i++) {
            scanf("%d", &grades[i]);
        }

        printf("Updated grades:\n");
        for (int i = 0; i < num_students; i++) {
            printf("Student %d: %d\n", i + 1, grades[i]);
        }

        // 释放内存
        free(grades);
    } else {
        printf("Memory allocation failed!\n");
    }

    return 0;
}

代码解释:

  • calloc(num_students, sizeof(int))：分配了足够存储 num_students 个 int 类型值的内存，并将所有内存初始化为零。
  • if (grades != NULL)：检查内存分配是否成功。
  • 输出初始化后的成绩，所有成绩应为0，因为 calloc 将内存初始化为零。
  • 允许用户输入每个学生的成绩，并输出更新后的成绩。
  • 使用 free(grades) 释放内存，避免内存泄漏。

输出结果:

Enter the number of students: 3
Initial grades (all should be 0):
Student 1: 0
Student 2: 0
Student 3: 0
Enter grades for each student:
90
85
88
Updated grades:
Student 1: 90
Student 2: 85
Student 3: 88

应用场景:

  • calloc 适用于需要初始化内存内容的场景，如创建并初始化数组或矩阵，尤其是当数组需要所有元素都设为零时。

1.3 realloc

功能: realloc 函数用于调整已分配内存块的大小。如果新大小比原来大，它会扩展内存块，并保留原有数据。否则，它会缩小内存块，并丢弃超出部分的数据。

标准格式:

void *realloc(void *ptr, size_t size);

参数:

  • ptr: 指向已分配内存块的指针。
  • size: 需要的新内存块的大小（以字节为单位）。

返回值:

  • 如果重新分配成功，realloc 返回指向新内存块的指针。如果原始内存块无法扩展，则 realloc 可能会分配一个新的内存块，将原数据复制到新块，并释放旧块。否则，返回 NULL，表示失败。

示例代码:

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

int main() {
    int initial_size = 5;
    int new_size = 10;

    // 分配初始内存
    int *data = (int *)malloc(initial_size * sizeof(int));

    // 检查内存是否分配成功
    if (data != NULL) {
        for (int i = 0; i < initial_size; i++) {
            data[i] = i + 1;
        }

        // 输出初始数据
        printf("Initial data: ");
        for (int i = 0; i < initial_size; i++) {
            printf("%d ", data[i]);
        }
        printf("\n");

        // 扩展内存块
        int *new_data = (int *)realloc(data, new_size * sizeof(int));

        // 检查内存扩展是否成功
        if (new_data != NULL) {
            // 初始化新增部分
            for (int i = initial_size; i < new_size; i++) {
                new_data[i] = i + 1;
            }

            // 输出所有数据
            printf("Data after realloc: ");
            for (int i = 0; i < new_size; i++) {
                printf("%d ", new_data[i]);
            }
            printf("\n");

            // 释放内存
            free(new_data);
        } else {
            printf("Memory reallocation failed!\n");
            free(data);
        }
    } else {
        printf("Memory allocation failed!\n");
    }

    return 0;
}

代码解释:

  • malloc(initial_size * sizeof(int))：初始分配内存用于存储5个整数。
  • realloc(data, new_size * sizeof(int))：将内存块大小扩展到10个整数。如果扩展成功，new_data 将指向新的内存块。
  • 使用 for 循环初始化新扩展的部分，并输出所有数据。
  • 使用 free(new_data) 释放内存。如果 realloc 失败，原内存块 data 保持不变，使用 free(data) 释放它。

输出结果:

Initial data: 1 2 3 4 5
Data after realloc: 1 2 3 4 5 6 7 8 9 10

应用场景:

  • realloc 适用于需要动态调整存储大小的情况，例如增加记录数或调整数据缓存。当程序运行时，数据量可能会变化，这时 realloc 可以帮助调整内存块的大小以适应新的需求。

1.4 free

功能: free 函数用于释放之前分配的内存块。它将内存标记为可用，以便以后重新分配。

标准格式:

void free(void *ptr);

参数:

  • ptr: 指向先前分配内存块的指针。

返回值:

  • 无返回值。

示例代码:

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

int main() {
    int *ptr = (int *)malloc(10 * sizeof(int));  // 分配内存

    // 检查内存是否分配成功
    if (ptr != NULL) {
        // 使用内存
        for (int i = 0; i < 10; i++) {
            ptr[i] = i * 2;
        }

        printf("Data in allocated memory: ");
        for (int i = 0; i < 10; i++) {
            printf("%d ", ptr[i]);
        }
        printf("\n");

        // 释放内存
        free(ptr);
        printf("Memory freed.\n");
    } else {
        printf("Memory allocation failed!\n");
    }

    return 0;
}

代码解释:

  • malloc(10 * sizeof(int))：分配内存用于存储10个整数。
  • 使用 for 循环初始化内存并输出数据。
  • 使用 free(ptr) 释放内存块，以避免内存泄漏。

输出结果:

Data in allocated memory: 0 2 4 6 8 10 12 14 16 18
Memory freed.

应用场景:

  • 在动态内存分配过程中，使用 free 释放不再使用的内存块，防止内存泄漏。

2. 内存管理函数的深层理解

2.1 内存分配的原理

内存分配函数如 malloc 和 calloc 基于操作系统提供的内存管理机制。它们通常通过系统调用请求一定大小的内存，并将这块内存从操作系统的内存池中分配给程序。不同的操作系统有不同的内存分配策略，但基本原理是相似的：

  • 分配内存：操作系统分配一定大小的内存块给程序。内存分配器通常会维护一个内存块列表，并根据请求的大小选择合适的内存块。
  • 释放内存：当程序调用 free 函数时，分配器将释放的内存块返回到内存池中。这块内存可以被其他内存分配请求重新使用。

2.2 内存分配的性能考虑

内存分配和释放的效率是程序性能的重要组成部分。以下是一些内存管理的性能考虑：

  • 内存碎片：频繁的分配和释放内存会导致内存碎片，使得系统难以找到足够大的连续内存块。为了减少内存碎片，现代内存分配器采用各种算法，如分区分配、伙伴系统等。
  • 内存池：使用内存池可以减少频繁的内存分配和释放操作，通过集中管理内存块来提高效率。
  • 避免内存泄漏：在程序中遗漏 free 调用会导致内存泄漏。内存泄漏会导致系统可用内存减少，最终可能导致程序崩溃。使用工具如 Valgrind 可以帮助检测内存泄漏。

2.3 动态调整内存块的大小

realloc 函数是调整内存块大小的关键工具。它的实现可能涉及以下步骤：

  • 分配新内存：如果需要扩展内存块，realloc 可能会分配一个新的更大的内存块。
  • 复制数据：将原内存块中的数据复制到新分配的内存块中。
  • 释放旧内存：释放原有的内存块。如果扩展成功，原内存块会被释放；否则，原内存块保持不变。

2.4 处理内存分配失败

内存分配失败可能是由于内存不足或其他资源限制。在编写程序时，处理内存分配失败是重要的编程实践：

  • 检查返回值：始终检查内存分配函数的返回值。如果返回值为 NULL，表示分配失败。
  • 释放已有内存：在内存分配失败的情况下，确保释放已经分配的内存，防止内存泄漏。
  • 错误处理：适当处理内存分配失败的情况，例如显示错误消息或采取其他补救措施。

3. 高级应用示例

3.1 内存池的实现

内存池是一种优化内存分配的方法，特别适用于频繁分配和释放固定大小内存块的场景。以下是一个简单的内存池实现示例：

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

#define POOL_SIZE 1024
#define BLOCK_SIZE 32

typedef struct MemoryPool {
    char pool[POOL_SIZE];
    int free_blocks;
    char *next_free;
} MemoryPool;

// 初始化内存池
void init_pool(MemoryPool *mp) {
    mp->free_blocks = POOL_SIZE / BLOCK_SIZE;
    mp->next_free = mp->pool;
}

// 从内存池中分配内存
void *pool_alloc(MemoryPool *mp) {
    if (mp->free_blocks > 0) {
        void *block = mp->next_free;
        mp->next_free += BLOCK_SIZE;
        mp->free_blocks--;
        return block;
    } else {
        return NULL; // 内存池满了
    }
}

// 释放内存池中的内存（简单示例，不处理内存块回收）
void pool_free(MemoryPool *mp) {
    init_pool(mp); // 重新初始化内存池
}

int main() {
    MemoryPool mp;
    init_pool(&mp);

    // 从内存池中分配内存
    char *block1 = (char *)pool_alloc(&mp);
    char *block2 = (char *)pool_alloc(&mp);

    // 检查分配是否成功
    if (block1 && block2) {
        sprintf(block1, "Hello, Memory Pool!");
        sprintf(block2, "Another block");

        printf("Block1: %s\n", block1);
        printf("Block2: %s\n", block2);
    } else {
        printf("Memory allocation failed!\n");
    }

    // 释放内存池中的内存
    pool_free(&mp);

    return 0;
}

代码解释:

  • init_pool：初始化内存池，设置起始地址和可用内存块数。
  • pool_alloc：从内存池中分配内存。如果内存池中有可用内存块，则返回内存块的地址；否则返回 NULL。
  • pool_free：释放内存池中的所有内存块，通过重新初始化内存池来实现。

输出结果:

Block1: Hello, Memory Pool!
Block2: Another block

应用场景:

  • 内存池适用于需要频繁分配和释放固定大小内存块的场景，如网络通信、游戏开发等。它能有效减少内存分配的开销，提高性能。

3.2 实现内存泄漏检测

内存泄漏检测工具如 Valgrind 可以帮助检测程序中的内存泄漏。下面是如何使用 Valgrind 来检测内存泄漏的简单示例：

  1. 编写一个可能有内存泄漏的程序（如不释放动态分配的内存）：
#include <stdio.h>
#include <stdlib.h>

int main() {
    int *arr = (int *)malloc(10 * sizeof(int));
    
    // 演示内存泄漏，未释放内存
    if (arr != NULL) {
        for (int i = 0; i < 10; i++) {
            arr[i] = i;
        }
        for (int i = 0; i < 10; i++) {
            printf("%d ", arr[i]);
        }
        printf("\n");
    }
    
    // 这里没有调用 free(arr)，导致内存泄漏

    return 0;
}
  1. 使用 Valgrind 检测内存泄漏：
valgrind --leak-check=full ./your_program

输出结果:

==12345== Memcheck, a memory error detector
==12345== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==12345== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info
==12345== Command: ./your_program
==12345== 
==12345== HEAP SUMMARY:
==12345==     in use at exit: 40 bytes in 1 blocks
==12345==   total heap usage: 1 allocs, 0 frees, 40 bytes allocated
==12345== 
==12345== 40 bytes in 1 blocks are definitely lost in loss record 1 of 1
==12345==    at 0x4C2FB55: malloc (vg_replace_malloc.c:309)
==12345==    by 0x4005D6: main (your_program.c:7)
==12345== 
==12345== LEAK SUMMARY:
==12345==    definitely lost: 40 bytes in 1 blocks
==12345==    indirectly lost: 0 bytes in 0 blocks
==12345==    possibly lost: 0 bytes in 0 blocks
==12345==    still reachable: 0 bytes in 0 blocks
==12345==    suppressed: 0 bytes in 0 blocks
==12345== 
==12345== For counts of detected and suppressed errors, rerun with: -v
==12345== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)

解释:

  • HEAP SUMMARY: 显示程序在退出时在堆上仍然占用的内存。上例显示有40字节内存在1个块中尚未释放。
  • LEAK SUMMARY: 汇总内存泄漏情况。显示 “definitely lost” 的40字节表示这些内存块确实没有被释放。
  • ERROR SUMMARY: 概述检测到的错误数量。

应用场景:

  • 内存泄漏检测工具如 Valgrind 是开发过程中重要的工具，尤其在复杂程序和长期运行的程序中，用于确保没有遗漏的内存释放，从而提高程序的稳定性和效率。

3.3 内存对齐与优化

内存对齐: 在某些架构中，为了提高内存访问效率，数据结构的内存布局可能需要对齐。例如，某些处理器要求数据的地址是特定字节边界对齐的。C语言提供了一些方法来确保内存对齐。

标准格式:

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

typedef struct {
    char a;
    int b;
    double c;
} ExampleStruct;

int main() {
    ExampleStruct *example = (ExampleStruct *)malloc(sizeof(ExampleStruct));
    
    if (example != NULL) {
        // 打印结构体的内存地址及其对齐情况
        printf("Address of struct: %p\n", (void *)example);
        printf("Offset of 'a': %zu\n", offsetof(ExampleStruct, a));
        printf("Offset of 'b': %zu\n", offsetof(ExampleStruct, b));
        printf("Offset of 'c': %zu\n", offsetof(ExampleStruct, c));

        free(example);
    }

    return 0;
}

代码解释:

  • offsetof 宏用于获取结构体成员的偏移量，以便了解它们在内存中的布局。
  • 通过 printf 输出结构体地址及各成员的偏移量，可以了解数据的内存对齐情况。

输出结果 (具体值取决于编译器和平台):

Address of struct: 0x12345678
Offset of 'a': 0
Offset of 'b': 4
Offset of 'c': 8

应用场景:

  • 内存对齐对于高性能应用程序至关重要，特别是在需要大量数据处理的应用程序中，如图形处理、科学计算等。

4. 常见问题与解决方案

4.1 内存泄漏

问题: 内存泄漏发生在程序分配内存后未能释放，导致内存使用量不断增加。

解决方案:

  • 确保每个 malloc、calloc 或 realloc 调用都有一个对应的 free 调用。
  • 使用内存泄漏检测工具如 Valgrind 定期检查程序中的内存泄漏。
  • 在代码审查中重点检查动态内存分配和释放的部分。

4.2 悬挂指针

问题: 悬挂指针是指向已经释放的内存块的指针。访问这些指针可能导致未定义行为或程序崩溃。

解决方案:

  • 在释放内存后，将指针设置为 NULL，以避免误用。
  • 在多线程环境中，确保对内存的访问和释放操作是线程安全的。

4.3 内存碎片

问题: 频繁的内存分配和释放可能导致内存碎片，使得无法分配足够大的连续内存块。

解决方案:

  • 使用内存池等优化技术来减少内存碎片。
  • 考虑使用 realloc 进行内存调整，而不是频繁地分配和释放内存。

4.4 不匹配的内存分配和释放

问题: 使用不同的内存分配函数配对释放，如使用 malloc 分配内存但使用 free 释放内存，而不是使用 calloc 和 free 组合等。

解决方案:

  • 确保内存分配和释放的函数配对正确，例如用 malloc 和 free 配对，calloc 和 free 配对。
  • 避免使用未定义的行为，遵循内存管理最佳实践。

5. 总结

C语言的内存管理函数 (malloc、calloc、realloc、free) 是动态内存分配的重要工具。了解这些函数的功能、使用方法和应用场景对于编写高效、稳定的程序至关重要。通过合理使用这些函数、处理常见问题、优化内存管理策略，可以显著提高程序的性能和可靠性。在实际应用中，结合使用内存池、内存泄漏检测工具和优化技术，将进一步提高程序的内存管理效率。

通过深入理解和正确使用这些内存管理函数，程序员能够有效地管理动态内存，减少内存泄漏和碎片，提高程序的稳定性和性能。

6. 结束语

  1. 本节内容已经全部介绍完毕，希望通过这篇文章，大家对C语言内存管理函数有了更深入的理解和认识。
  2. 感谢各位的阅读和支持，如果觉得这篇文章对你有帮助，请不要吝惜你的点赞和评论，这对我们非常重要。再次感谢大家的关注和支持！点我关注❤️

相关文章：

皮卡丘
关注
  • 20
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言指针详细讲解ppt课件.ppt
11-19
本资源详细讲解了C语言中的指针概念，包括指针的定义、指针变量、指针与数组、指针与函数返回值等内容。通过详细的讲解和实例，帮助读者深入了解C语言中的指针机制。 指针的概念 指针是C语言中的一种特殊变量，...
C语言内存精讲.rar
03-19
本资源“C语言内存精讲.rar”包含了深入讲解C语言内存管理的资料，这对于想要深入学习C语言的程序员来说是一份宝贵的参考资料。 C语言的内存主要分为三个区域：栈（Stack）、堆（Heap）和静态存储区（Static Memory...
C语言内存函数超详细讲解
wer24_25的博客
05-18 1263
C语言内存函数超详细讲解,包含memcpy,memmove,memset,memcmp,超详细讲解,小白可以轻松入门.
C语言中的函数（超详细）
热门推荐
m0_68662723的博客
07-25 5万+
我们都知道函数是数学里的重要组成部分，数学中我们常见到函数的概念，但是你了解C语言中的函数吗？其实函数就相当于一个子程序，那什么是子程序呢？在计算机科学中，子程序是一个大型程序中的某部分代码， 由一个或多个语句块组成。它负责完成某项特定任务，而且相较于其他代 码，具备相对的独立性。一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软件库。如果库函数能干所有的事情，那还要程序员干什么？所有更加重要的是自定义函数！！！
C语言函数详细讲解
weixin_58275377的博客
07-27 1176
C语言:函数介绍
【C语言】内存函数
"謓泽"正在路上朝着"攻城狮"方向"前进四"!
08-04 1084
🎆memcpy() - 内存拷贝不重叠🎇 🎆memcpy()代码示例🎇 🎆创建自定义函数实现memcpy()🎇 🎉memmove() - 内存拷贝可重叠🎊 🎉memmove()代码示例🎊 🎉创建自定义函数实现memmove()🎊 🍔memcmp() - 内存比较🍟 🍔memcpy()代码示例🍟 🍔memcpy()源程序🍟 🎄memset() - 内存填充块🎋 🎄memset()代码示例🎋 🎄memset()源程序🎋......
C语言动态内存分配函数
ZHA_123的博客
10-06 1750
通讯录大小是100，即最多只能存100个联系人的信息，那如果我们在使用时，需要存200人甚至更多人呢？ 那这个程序就不能满足我们的需求了。 而需要解决这个问题，我们就得学会使用C语言动态内存分配函数，对通讯录的大小进行动态分配。本篇博客会对动态内存分配函数进行讲解，一起来看看吧
C语言函数目录，和讲解
10-26
函数是C语言中的核心元素，它们是代码的可重用模块，允许我们将大任务分解为小的、可管理的部分。本资料包包含了关于C语言函数的重要资源，包括“C函数参考手册”和“C函数目录”，这些文档将帮助你深入理解和掌握...
C语言中建立和删除文件连接的相关函数讲解
07-30
"C语言中建立和删除文件连接的相关函数讲解" C语言中建立和删除文件连接的相关函数讲解是C语言基础课中一个重要的知识点。这篇文章主要介绍了C语言中建立和删除文件连接的相关函数讲解，分别为link和unlink函数的...
Linux--C语言之分支结构
2201_75773226的博客
08-10 889
​ 1.如果只需要一个判断结果，使用单分支​ 2.如果需要两个判断结果，且只能有两个判断结果，使用双分支​ 3.如果需要判断N个结果中的某几个，或者所有，使用多分支。
C语言 --- 枚举、位运算
weixin_62989562的博客
08-10 857
eg：（1）int a;//定义了一个int型变量a//此时a 是int 类型的一个别名stu_t s;
paho-mqtt-c交叉编译
让代码改变世界
08-08 342
先提前说下，这些库不同的版本可能有较大差异（本人使用的openssl版本是3.3.0，paho-mqtt-c版本是1.3.13），如果发现跟自己的环境不一致，请酌情参考。 1. 下载源代码 有外网可以去github上下载，这里贴一个下载好的 paho-mqtt-c 2. 在根目录下建一个build文件夹，切换到里面，再建一个install文件夹 paho.mqtt.c$ mkdir build/install -p paho.mqtt.c$ cd build/ paho.mqtt.c/buil
C++笔记5•内存管理•
最新发布
qq_64446190的博客
08-12 688
内存管理
c++ error: ‘*’ does not name a type； did you mean ‘**’?
xiaozhi
08-08 479
c++ error: ‘*’ does not name a type； did you mean ‘**’?
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 368
STL中的迭代器失效（vector为例）
【C++】智能指针
dab112的博客
08-07 931
谈论了内存泄漏，以及可以使用智能指针来解决该类问题
C语言一维数组(含数组二分查找)
hdxbufcbjuhg的博客
08-09 1188
在⼀个升序的数组中查找指定的数字n，很容易想到的⽅法就是遍历数组，但是这种⽅法效率⽐较低。比如我们之前写的猜数字游戏，会生成一个随机数来让玩家猜，范围是1~100，那玩家会从1开始一个一个猜吗，不会吧，那样就太慢了，我们一般会从整体的一半开始猜，比如猜50，告诉你大了还是小了，这样只需要一步就可以排除庞大数字中的一半，比如假设猜1 ~ 10000，猜5000后就可以知道猜大了还是小了，直接排除了5000个数字，效率很快，这就是⼆分查找，也叫折半查找。
理解栈（Stack）及其在 C++ 中的应用【栈、数据结构】
qq_22841387的博客
08-07 442
栈是一种数据结构，它遵循“后进先出”（LIFO - Last In, First Out）的原则。栈就像是一叠盘子，你只能从最上面拿盘子，也只能在最上面放盘子。栈的这一特性使其在很多场景中非常有用，例如递归、回溯算法和表达式计算等。通过这篇博客，我们详细介绍了栈的基本概念及其在 C++ 中的实现。栈是一种非常有用的数据结构，尤其在处理递归、回溯和表达式计算等问题时。我们还讨论了如何将栈中的字符转换为字符串，以及如何使用栈解决括号匹配问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值