C语言_ch08_6_指针数组与多重指针 动态内存分配(精选)
C语言中动态数组的实现
C语言中动态数组的实现在C语言中，动态数组的实现主要依靠指针和内存分配函数。
动态数组是在程序执行过程中根据需要动态分配内存空间的数组。
相比于静态数组，在编写代码时不需要提前指定数组的大小，可以更加灵活地适应不同数据量的需求。
C语言中的动态数组实现主要分为两个步骤：内存分配和内存释放。
1.内存分配：C语言提供了几种内存分配函数来动态分配内存空间，包括malloc、calloc、realloc等。
a) malloc函数：malloc函数用于从堆中分配指定大小的内存块，并返回该内存块的首地址。
其函数原型为：```cvoid* malloc(size_t size);```这里的size是以字节为单位的分配内存的大小。
分配成功时，返回分配内存的首地址；分配失败时，返回NULL。
b) calloc函数：calloc函数用于从堆中分配指定数量、指定大小的连续内存空间，并将该内存空间初始化为0。
其函数原型为：```cvoid* calloc(size_t num, size_t size);```这里的num是要分配的元素个数，size是每个元素的大小。
分配成功时，返回分配内存的首地址；分配失败时，返回NULL。
c) realloc函数：realloc函数用于重新调整之前分配的内存大小，并返回调整后的内存地址。
其函数原型为：```cvoid* realloc(void* ptr, size_t size);```这里的ptr是之前分配的内存地址，size是调整后的内存大小。
如果调整成功，返回调整后的内存地址；如果调整失败，返回NULL。
2.内存释放：动态数组使用完毕后，需要手动释放分配的内存空间，避免内存泄漏。
C语言中使用free函数来释放动态分配的内存空间，函数原型为：```cvoid free(void* ptr);```这里的ptr为之前分配的内存地址。
释放成功后，内存空间可以被重新分配使用；如果指针为空指针，则不进行任何操作。
C语言动态内存分配与释放
C语言动态内存分配与释放C语言作为一门广泛应用的编程语言，具有良好的灵活性和高效性。
在C语言中，动态内存分配与释放是一项重要的特性，它可以在程序运行过程中根据需要动态分配内存，并在使用完毕后释放，避免内存浪费和内存泄漏的问题。
本文将深入探讨C语言中的动态内存分配与释放的相关知识。
1. 动态内存分配概述在C语言中，使用静态内存分配的方式会提前将内存分配给变量，这在一些情况下会导致内存的浪费。
为了更加高效地利用内存，C语言提供了动态内存分配的机制。
动态内存分配允许我们在程序运行时根据需要动态地分配内存空间给变量或数据结构，并且在不再需要的时候释放这些内存空间。
2. 动态内存分配函数C语言提供了几个常用的动态内存分配函数，包括malloc、calloc、realloc和free。
- malloc函数：用于在堆中分配指定大小的内存空间，并返回指向该空间起始地址的指针。
- calloc函数：用于在堆中分配指定数量和大小的内存空间，并将内存空间初始化为0。
- realloc函数：用于调整已分配内存空间的大小，可以扩大或缩小内存空间。
- free函数：用于释放之前通过动态内存分配函数分配的内存空间。
3. 动态内存分配的示例下面是一个示例代码，演示了如何使用动态内存分配函数来分配内存空间，并在使用完毕后释放内存空间。
```c#include <stdio.h>#include <stdlib.h>int main() {int n;printf("请输入元素个数：");scanf("%d", &n);int* arr = (int*)malloc(n * sizeof(int)); // 使用malloc函数动态分配n个int型变量所占的内存空间if (arr == NULL) {printf("内存分配失败！");return 1; // 内存分配失败，退出程序}for (int i = 0; i < n; i++) {printf("请输入第%d个元素的值：", i + 1);scanf("%d", &arr[i]);}printf("输入的元素为：");for (int i = 0; i < n; i++) {printf("%d ", arr[i]);}free(arr); // 释放动态分配的内存空间return 0;}```在上述示例中，我们通过malloc函数动态分配了一个整型数组的内存空间，并在使用完毕后使用free函数将其释放，以避免内存泄漏。
C语言数组与指针详解
C语言数组与指针详解C语言数组与指针详解由于数据的表现形式多种多样，还有字符型和其它的数值类型，因此仅有基本数据类型是不够的。
是否可以通过基本数据类型的组合抽象构造其它的数据类型呢?下面是店铺为大家带来的C语言数组与指针详解的知识，欢迎阅读。
1.数组(1)数组的声明我们知道，一个基本数据类型的变量只能存储一个数据，比如：int data = 0x64;如果需要存储一组int型数据呢?比如，1、2、3，则至少需要3个变量data0、data1、data2。
比如：int data0 = 1, data1 = 2, data2 =3;由于数据的表现形式多种多样，还有字符型和其它的数值类型，因此仅有基本数据类型是不够的。
是否可以通过基本数据类型的组合抽象构造其它的数据类型呢?答案是可以的，构造数据类型数组就是这样产生的。
从概念的视角来看，int型整数1、2和3都是相同的数据类型，data0、data1和data2三个变量的共性是data，其差异性是下标不一样。
因此可以将data0、data1和data2抽象为一个名字，然后用下标区分这些变量的集合——data[0]、data[1]和data[2]。
如果有以下声明：intdata[3]; //解读为data是int数组(元素个数3)那么data[3]就成了存放3个int型数据1、2、3的data[0]、data[1]和data[2]所组成的数组，即可分别对data[0]、data[1]和data[2]赋值：data[0] = 1, data[1] =2, data[2] = 3;当然，也可以按照以下方式声明一个数组并进行初始化：intdata[3] = {1, 2, 3};通常将data称为数组(变量)名，data[0]、data[1]和data[2]被称为变量。
因而可以说，数组是将相同类型数据的若干变量按有序的形式组织起来，用一个名字命名，然后用下标区分这些变量的集合。
C语言指针和动静态分配内存
C语⾔指针和动静态分配内存1、静态数组的缺陷在之前的分配数组中有两个缺陷：1、在定义数组的时候必须指定数组的长度，只能是常量，⽽不是变量；2、之前的定义数组中，程序员⽆法⼿动的进⾏释放数组的内存；只能够在本函数中运⾏完毕时，由操作系统来进⾏释放。
在该函数运⾏期间，该函数中数组所占⽤的空间会⼀直空间。
3、数组在当前函数运⾏期间，不能够动态扩充或者缩⼩，⼀旦定义，就不能够发⽣改变。
4、在函数中定义的数组中，可以被其他函数所使⽤，但是在定义数组的函数中⼀旦运⾏结束，那么数组将会被操作系统释放。
传统定义的数组的释放是由操作系统来进⾏释放，可以跨函数使⽤，但是数组所在的函数⼀旦运⾏结束，其他函数将不能够使⽤了，因为已经被释放了，没有权限继续去使⽤了2、动态分配动态分配数组可以解决上⾯的问题。
malloc函数是memory allocate内存分配的缩写。
要使⽤malloc函数，导⼊⼀个头⽂件:# include <malloc.h>malloc函数只有⼀个形参，并且实参是⼀个整形的数据；形参表⽰的是请求操作系统为本程序分配整数个字节；malloc函数只能够返回第⼀个字节的地址，但是可以根据数据类型确定占⽤了⼏个字节int i = 100;int * p = (int *)malloc(4);拿上⾯的来举例⼦，请求操作系统分配4个字节给本段程序，然后返回给p指针，但是因为之前说过了p指针保存的是内存单元的值，那么p中保存的就是64位的01代码，也就是8个字节，保存的就是分配的内存单元的地址，也就是第⼀个内存单元的地址，根据前⾯的数据类型可以找到分配的内存单元有⼏个。
所以这⾥使⽤了强制转换类型来进⾏操作的。
这⾥也可以这样⼦来书写：int i = 100;int * p = (int *)malloc(sizeof(int));编写个程序：# include <stdio.h># include <malloc.h>int main(void){int i = 100;int * p = (int *)malloc(sizeof(int));p = &i;printf("p中保存的是值：%d\n",p);printf("p中保存的是值：%d\n",&i);return 0;}查看控制台输出：p中保存的是值：6487572p中保存的是值：6487572--------------------------------Process exited after 0.2071 seconds with return value 0请按任意键继续. . .再对上⾯描述的⼀段代码来进⾏深⼊理解：int * p = (int *)malloc(sizeof(int));这段代码有静态分配，也有动态分配。
C语言_ch08_6_指针数组与多重指针动态内存分配
2020/7/23
5
例8.27 将多个字符串按字母顺序(由小到大)输出。
#include <stdio.h> #include <string.h> void sort(char *names[], int n); void print(char *names[], int n);
int main() {
int main(int argc, char *argv[])
argc：命令行参数个数，包括命令字(可执行文件名)
argv：是一个指针数组，用来存放命令行中各个参数 和命令字的字符串，并且规定： argv[0]存放命令字 argv[1]存放命令行中第一个参数 argv[2]存放命令行中第二个参数 ……
char *names[] = { "Follow me", "BASIC", "Great Wall", "FORTRAN", "Computer Design"
}; int n = sizeof(names)/sizeof(names[0]); sort(names, n); print(names, n); }
{
p = name + i;
printf("%s\n", *p);
}
}
2020/7/23
13
8.7.3 指针数组作main函数的形参
在cmd命令行, 可通过输入可执行文件名来执行。 常见dos命令举例
dir cd type ipconfig ping …
2020/7/23
16
main()函数的形参
int i; for (i=0; i<n; i++)
指针数组和数组指针 释放
指针数组和数组指针释放指针数组和数组指针是C语言中常见的概念，它们在内存管理和数据访问方面起着重要作用。
本文将从人类视角出发，以真实的叙述方式介绍指针数组和数组指针的释放。
在C语言中，指针数组和数组指针都是指针的应用形式，它们与普通的数组有所不同。
指针数组是一个数组，其元素是指针类型；而数组指针是一个指针，指向一个数组。
两者在释放内存时需要注意不同的操作。
我们来看指针数组的释放。
假设我们有一个指针数组ptrArray，其中包含了若干个指针。
在释放内存之前，我们需要逐个释放数组中的指针指向的内存块。
可以通过循环遍历数组的方式，依次释放每个指针指向的内存。
释放完毕后，再使用free函数释放指针数组本身所占用的内存。
这样，我们就完成了指针数组的释放过程。
接下来，我们来看数组指针的释放。
假设我们有一个数组指针pArray，指向一个数组。
在释放内存之前，我们只需使用一次free 函数即可释放整个数组所占用的内存。
因为数组指针指向的是一个连续的内存块，只需释放一次即可。
需要注意的是，在释放指针数组和数组指针时，应确保内存的正确释放顺序。
先释放指针数组中的指针，再释放指针数组本身；先释放数组指针指向的内存，再释放数组指针本身。
这样可以避免内存泄漏和悬空指针的问题。
总结一下，指针数组和数组指针的释放方法是不同的。
对于指针数组，需要逐个释放数组中的指针，并最后释放指针数组本身；对于数组指针，只需一次释放即可。
在释放内存时，需要注意释放的顺序，以确保内存的正确释放。
通过以上的叙述，希望读者能够更好地理解指针数组和数组指针的释放方法，并能够正确地应用于实际的程序开发中。
同时也希望读者能够通过本文的描述，感受到指针数组和数组指针的重要性，以及在内存管理中的作用。
让我们一起努力，深入理解指针数组和数组指针，提升自己在C语言中的编程能力。
C语言的内存分配方式
C语言的内存分配方式1.静态内存分配：静态内存分配是指在程序编译时，为变量和对象分配固定的内存空间。
这些变量和对象在程序的整个生命周期中都存在，不会被自动释放。
静态变量声明在函数体外部，它们在程序启动时自动初始化，只分配内存一次，并且在程序结束时被释放。
静态变量可以在函数内部使用static关键字进行声明。
这些变量也只分配一次内存空间，但它们具有全局可见性，在函数调用之间保持状态。
2.栈内存分配：栈内存分配是指在函数调用时，为局部变量和函数参数分配内存空间。
栈是一种后进先出（LIFO）的数据结构，用于存储临时变量，函数调用信息等。
栈内存的分配和释放都由编译器自动处理，不需要手动管理。
当函数调用结束时，栈帧被销毁，局部变量的内存空间也被释放，可以被重新使用。
3.堆内存分配：堆内存分配是指在程序运行时，动态地为变量和对象分配内存空间。
堆是一种由操作系统维护的动态数据结构，它提供了灵活的内存管理方式。
在C语言中，可以使用malloc, calloc, realloc等函数分配堆内存。
这些函数分配的内存空间在不需要时需要手动释放，以防止内存泄漏。
堆内存的分配方式灵活，可以根据程序的需要动态调整。
但是，堆内存的分配和释放需要程序员手动管理，如果管理不当，可能会导致内存泄漏或者内存溢出等问题。
总结：C语言的内存分配方式包括静态内存分配、栈内存分配和堆内存分配。
静态内存分配在程序编译时完成，分配的内存空间在整个程序的生命周期内存在。
栈内存分配在函数调用时完成，分配的内存空间在函数调用结束时被自动释放。
堆内存分配在程序运行时动态进行，分配的内存空间需要手动释放。
不同的内存分配方式有各自的特点和适用场景，程序员需要根据具体情况选择合适的内存分配方式，以实现高效的内存管理。
c语言结构体动态分配内存
c语言结构体动态分配内存C语言中的结构体动态分配内存在C语言中，结构体是一种自定义的数据类型，可以将不同类型的数据组合在一起，形成一个新的数据类型。
结构体的定义只是描述了这种新的数据类型的形式，而在实际使用时，需要为结构体分配内存空间。
本文将介绍如何在C语言中动态分配内存给结构体。
动态分配内存是指在程序运行时根据需要动态地分配内存空间。
相对于静态分配内存，动态分配内存具有更大的灵活性和效率。
在C 语言中，动态分配内存的函数是malloc()和free()。
我们需要定义一个结构体类型。
例如，我们定义一个学生的结构体类型，包含姓名和年龄两个成员变量：```ctypedef struct {char name[20];int age;} Student;```接下来，我们可以使用malloc()函数为结构体类型分配内存空间。
malloc()函数接收一个参数，即需要分配的内存大小（以字节为单位），并返回分配的内存的首地址。
```cStudent *stu_ptr;stu_ptr = (Student *)malloc(sizeof(Student));```上述代码中，我们使用了sizeof()运算符来获取结构体类型的大小，并将其作为参数传递给malloc()函数。
由于malloc()函数返回的是void指针类型，我们需要将其强制转换为Student类型的指针。
接下来，我们可以像使用普通变量一样使用结构体指针。
例如，我们可以给结构体的成员变量赋值：```cstrcpy(stu_ptr->name, "Tom");stu_ptr->age = 18;```在使用完结构体后，我们需要使用free()函数释放分配的内存空间，以防止内存泄漏。
```cfree(stu_ptr);```在释放内存空间后，我们不能再使用被释放的指针，否则会导致未定义的行为。
动态分配内存给结构体的好处是可以根据需要灵活地分配和释放内存空间，避免了内存浪费。
c语言中给指针的指针申请内存空间
《深入探讨C语言中给指针的指针申请内存空间》1.前言在C语言中，指针的使用是非常重要的一部分。
而指针的指针，也就是双重指针，更是在一些特定情况下非常实用和必要。
本文将针对C语言中给指针的指针申请内存空间这一复杂而重要的话题展开深入探讨。
2.简述指针和指针的指针在C语言中，指针可以用来存储变量的位置区域，通过指针可以直接访问和修改变量的值。
而指针的指针则是指向指针的指针变量，用来存储指针变量的位置区域。
这种多重间接性的概念在一些场景下可以极大地提高程序的灵活性和效率。
3.为指针的指针申请内存空间在C语言中，为指针的指针申请内存空间需要使用二级指针，也就是指向指针的指针。
通过使用一级指针来动态分配内存空间，从而为二级指针分配内存空间。
4.动态内存分配 C语言提供了标准库函数来进行动态内存分配，如malloc()、calloc()、realloc()等。
在为指针的指针申请内存空间时，可以通过这些函数来实现。
5.实际操作和示例接下来，我们将通过具体的代码示例来演示如何为指针的指针申请内存空间。
假设我们需要定义一个二维数组，而数组的行数是动态的，那么我们就需要使用指针的指针来实现。
#include <stdio.h>#include <stdlib.h>int main() {int i, j;int **arr; // 定义指针的指针int rows = 3, cols = 4; // 假设行数为3，列数为4// 申请内存空间arr = (int **)malloc(rows * sizeof(int *));for (i = 0; i < rows; i++) {arr[i] = (int *)malloc(cols * sizeof(int)); }// 对二维数组赋值并输出for (i = 0; i < rows; i++) {for (j = 0; j < cols; j++) {arr[i][j] = i * cols + j;printf("%d ", arr[i][j]);}printf("\n");}// 释放内存空间for (i = 0; i < rows; i++) {free(arr[i]);}free(arr);return 0;}在这个示例中，我们首先定义了一个指向指针的指针arr，然后使用malloc()函数为一级指针和二级指针分别申请了内存空间。
C语言中多维数组的内存分配和释放（malloc与free）的方法
C语⾔中多维数组的内存分配和释放（malloc与free）的⽅法如果要给⼆维数组(m*n)分配空间，代码可以写成下⾯：复制代码代码如下:char **a, i;// 先分配m个指针单元，注意是指针单元// 所以每个单元的⼤⼩是sizeof(char *)a = (char **) malloc(m * sizeof(char * ));// 再分配n个字符单元，// 上⾯的m个指针单元指向这n个字符单元⾸地址for(i = 0; i < m; i++)a[i] = (char * )malloc(n * sizeof(char ));释放应该是：复制代码代码如下:int i;for(i=0;i<m;i++)free((void *)a[i]);free((void *)a);如果为三维数组(m*n*p)分配空间呢，应该是：复制代码代码如下:char ***a, i, j;a = (char ***) malloc(m * sizeof(char ** ));for(i = 0; i < m; ++i)a[i] = (char **) malloc(n * sizeof(char * ));for(i = 0; i < m; ++i)for(j = 0; j < n; ++j)a[i][j] = (char * )malloc(p * sizeof(char ));释放代码为逆过程，具体代码为：复制代码代码如下:int i,j,;for(i = 0; i < m; ++i)for(j = 0; j < n; ++j)free((void *)a[i][j]);for(i = 0; i < m; ++i)free((void *)a[i]);free((void *)a);三维以上的多维数组的分配和释放，原理与上⾯的⼀样。
动态分区分配算法c语言代码
动态分区分配算法c语言代码动态分区分配算法是操作系统管理内存时不可或缺的一部分。
它能够动态地将物理内存划分成多个分区，并向进程提供所需的内存空间。
因此，使用动态分区分配算法，可以提高操作系统的内存利用率，优化内存管理。
动态分区分配算法的实现非常复杂，但是通过c语言，可以精确地描述出这一算法。
一般而言，动态分区分配算法需要考虑以下几个方面：1. 内部碎片问题：由于分配内存时分配的大小和分区大小并不总是完全匹配，会产生未使用的部分。
动态分区分配算法需要减少这种情况的发生。
2. 外部碎片问题：在进程运行结束后，会留下未使用的内存。
这些未使用的内存小于内存分区大小，被称为外部碎片。
动态分区分配算法需要将这些未使用的小块内存合并起来，以供分配。
在c语言中，动态分区分配算法的实现方式可以借助链表的数据结构，来实现对内存空间的分配与释放。
一个内存分区对应的链表节点，包含了分区的起始地址，分区的大小以及该分区的状态（是否被分配或是否为空）等信息。
下面是一个简单的动态分区分配算法的示例代码。
在这个代码中，初始化时，将整个可用内存视为一个空闲分区，并创建分配内存时使用的节点。
分配内存时，会遍历空闲分区链表，找到第一个大小足够的分区并将其分配。
释放内存时，遍历已分配分区链表，找到需要释放的分区，并将其状态更改为未分配，并将其添加到空闲分区链表中。
```include <stdio.h>include <stdlib.h>include <stdbool.h>// 内存分区结构体typedef struct partition {int size; // 分区大小bool allocated; // 是否被分配struct partition* next; // 下一个分区节点} partition_t;// 全局链表头节点指针partition_t* head;// 初始化函数void initialize(int size) {head = (partition_t*)malloc(sizeof(partition_t));head->size = size;head->allocated = false;head->next = NULL;}// 分配函数void* allocate(int size) {partition_t* current = head;while (current != NULL) {if (current->size >= size && !current->allocated) {if (current->size == size) {current->allocated = true;} else {partition_t* new_part =(partition_t*)malloc(sizeof(partition_t));new_part->size = size;new_part->allocated = true;new_part->next = current->next;current->size -= size;current->next = new_part; }return (void*)(current + 1); }current = current->next;}printf("Memory allocation failed\n"); return NULL;}// 释放函数void free_memory(void* ptr) {partition_t* current = head;partition_t* prev = head;while (current != NULL) {if ((void*)(current + 1) == ptr) { current->allocated = false;// 尝试合并空闲分区节点if (prev != head && !prev->allocated) {prev->size += current->size;prev->next = current->next;free(current);current = prev;}if (current->next != NULL && !current->next->allocated) {current->size += current->next->size;partition_t* temp = current->next;current->next = current->next->next;free(temp);}return;}prev = current;current = current->next;}printf("Memory free failed\n");}int main() {// 初始化内存initialize(1000);// 分配内存int* p = (int*)allocate(sizeof(int));if (p != NULL) {*p = 10;}// 释放内存free_memory(p);return 0;}```在实际应用中，动态分区分配算法可能会使用更加复杂的内存分配方式，例如“首次适应算法”、“最佳适应算法”、“最坏适应算法”等。
课件C语言动态分配内存共64页文档
16、业余生活要有意义，不要越轨。——华盛顿 17、一个人即使已登上顶峰，也仍要自强不息。——罗素·贝克 18、最大的挑战和突破在于用人，而用人最大的突破在于信任人。——马云 19、自己活着，就是为了使别人过得更美好。——雷锋 20、要掌握书，莫被书掌握；要为生而读，莫为读而生。——布尔沃
END
课件C语言动态分配内存
36、如果我们国家的法律中只有某种 神灵， 而不是 殚精竭 虑将神 灵揉进 温 37、纲纪废弃之日，便是暴政兴起之 时。— —威·皮 物特
38、若是没有公众舆论的支持，法律 是丝毫 没有力 量的。 ——菲 力普斯 39、一个判例造出另一个判例，它们 迅速累 聚，进 而变成 法律。 ——朱 尼厄斯
c动态分配内存的方法
c动态分配内存的方法动态分配内存是计算机编程中的一个重要概念，它允许程序在运行时动态地分配所需的内存空间。
而中括号（[]）通常被用作数组的标志，所以本文将以中括号为主题，讨论动态分配内存的方法。
以下将逐步回答这个问题，并介绍几种常见的动态分配内存的方法。
一、为什么需要动态分配内存？在程序运行过程中，有时我们无法确定需要多少内存空间来存储某些数据。
例如，用户可能输入一个未知长度的字符串，或者需要在运行时根据输入动态创建一个数组。
在这种情况下，静态分配内存将是不切实际的，因为我们无法提前预知所需内存的大小。
因此，动态分配内存是必要的。
二、使用new和delete操作符动态分配和释放内存在C++中，我们可以使用new和delete操作符来动态分配和释放内存。
对于基本数据类型（如整数、浮点数等），可以使用以下方法：cppint* ptr = new int; 分配一个整数类型的内存空间*ptr = 10; 向分配的内存空间存储值使用分配的内存空间std::cout << *ptr << std::endl;delete ptr; 释放分配的内存空间对于数组，可以使用以下方法：cppint size;std::cout << "请输入数组大小：";std::cin >> size;int* arr = new int[size]; 动态分配一个大小为size的整数数组使用分配的数组for (int i = 0; i < size; i++) {arr[i] = i * 2;std::cout << arr[i] << " ";}delete[] arr; 释放分配的数组内存空间三、使用malloc和free函数动态分配和释放内存在C语言中，我们可以使用malloc和free函数来动态分配和释放内存。
C语言中关于动态内存分配的详解
C语⾔中关于动态内存分配的详解⽬录⼀、malloc 与free函数⼆、calloc三、realloc四、常见的动态内存的错误【C语⾔】动态内存分配本期，我们将讲解malloc、calloc、realloc以及free函数。
这是个动态内存分配函数的头⽂件都是 <stdlib.h>。
c语⾔中动态分配内存的函数，可能有些初学c语⾔的⼈不免要问了：我们为什么要通过函数来实现动态分配内存呢？⾸先让我们熟悉⼀下计算机的内存吧！在计算机的系统中⼤致有这四个内存区域：1）栈：在栈⾥⾯储存⼀些我们定义的局部变量以及形参（形式参数）；2）字符常量区：主要是储存⼀些字符常量，⽐如：char *p=”hello world”;其中”hello world”就储存在字符常量区⾥⾯；3）全局区：在全局区⾥储存⼀些全局变量和静态变量；堆：堆主要是通过动态分配的储存空间，也就是我们接下需要讲的动态分配内存空间。
静态内存和动态内存的⽐较：静态内存是有系统⾃动分配，由系统⾃动释放。
静态内存是在栈分配的。
（例如：函数⾥的局部变量）动态内存是由程序员⼿动分配，⼿动释放。
动态内存是在堆分配的。
（例如：⽤C语⾔写链表时，需要⾃⼰对Node结点分配内存空间）⼀、malloc 与free函数void* **malloc( size_t ** size);返回类型： void*，也就是说这个函数的可以返回所有类型的指针形式。
只需要在开辟空间的时候进⾏强制类型转换⼀下即可。
函数参数：size_t size, 这个参数就是告诉这个函数，你需要开辟多少个字节的内存空间。
void free(void* memblock) ；没有返回参数。
函数参数：void* memblock， free函数可以接收来⾃所有类型指针的动态分配的内存空间。
⼀切以栗⼦来描述吧：#include <stdlib.h>#include <stdio.h>int main(){//开辟10个int类型的空间int* arr = (int*)malloc(10 * sizeof(int)); //切记这⾥给的⼤⼩，是10 * int（4个字节）int i = 0;if (arr == NULL){perror("malloc"); //有可能，malloc开辟空间失败，则malloc会返回NULLreturn 1;}for (i = 0; i < 10; i++)*(arr + i) = i; //放⼊数据 0 (9)for (i = 0; i < 10; i++)printf("%d ",*(arr + i));//记得释放所开辟的空间free(arr);return 0;}⼆、callocvoid* calloc (size_t num， size_t** size );返回类型：与malloc函数是⼀样的，就不在多说了。
c指针和动态内存分配
Chapter Nine: Pointers and Dynamic Memory
9.1 Variable address(变量地址)
• Every variable object used in a C++ program is stored in a specific place in memory. Each location in memory has a unique address, in the same way that every house in a street has a unique address.(在C++程序中使用的每个变量和对象， 都存储在内存中特定的存储单元中。每个存储 单元都有唯一的地址，就像街道旁的每个房子 都有唯一的地址一样。）
13
Chapter Nine: Pointers and Dynamic Memory
9.4 Using const with pointers
(使用const修饰指针变量) When defining a pointer, the pointer itself, the value it points to or both can be made constant. The position of const in the definition determines which of these apply.(定义指针变量时，指针变量本身、 指针变量所指向的数据都可以声明为常量。变量 定义中的const的位置决定了谁被声明为常量。)
#include <iostream> using namespace std; main() { int var =1; int* ptr; ptr=&var; // ptr contains the address of var cout << "ptr contains " << ptr << endl ; cout << “*ptr contains " << *ptr << endl ; }
C语言编程常见问题解答之指针和内存分配
C语言编程常见问题解答之指针和内存分配指针为C语言编程提供了强大的支持--如果你能正确而灵活地利用指针，你就可以直接切入问题的核心，或者将程序分割成一个个片断。
一个很好地利用了指针的程序会非常高效、简洁和精致。
利用指针你可以将数据写入内存中的任意位置，但是，一旦你的程序中有一个野指针("wild"pointer)，即指向一个错误位置的指针，你的数据就危险了--存放在堆中的数据可能会被破坏，用来管理堆的数据结构也可能会被破坏，甚至操作系统的数据也可能会被修改，有时，上述三种破坏情况会同时发生。
此后可能发生的事情取决于这样两点：第一，内存中的数据被破坏的程度有多大；第二，内存中的被破坏的部分还要被使用多少次。
在有些情况下，一些函数(可能是内存分配函数、自定义函数或标准库函数)将立即(也可能稍晚一点)无法正常工作。
在另外一些情况下，程序可能会终止运行并报告一条出错消息；或者程序可能会挂起；或者程序可能会陷入死循环；或者程序可能会产生错误的结果；或者程序看上去仍在正常运行，因为程序没有遭到本质的破坏。
值得注意的是，即使程序中已经发生了根本性的错误，程序有可能还会运行很长一段时间，然后才有明显的失常表现；或者，在调试时，程序的运行完全正常，只有在用户使用时，它才会失常。
在C语言程序中，任何野指针或越界的数组下标(out-of-bounds array subscript)都可能使系统崩溃。
两次释放内存的操作也会导致这种结果。
你可能见过一些C程序员编写的程序中有严重的错误，现在你能知道其中的部分原因了。
有些内存分配工具能帮助你发现内存分配中存在的问题，例如漏洞(leak，见7．21)，两次释放一个指针，野指针，越界下标，等等。
但这些工具都是不通用的，它们只能在特定的操作系统中使用，甚至只能在特定版本的编译程序中使用。
如果你找到了这样一种工具，试试看能不能用，因为它能为你节省许多时间，并能提高你的软件的质量。
C语言动态内存分配的详解及实例
C语⾔动态内存分配的详解及实例1. 动态内存分配的意义(1)C 语⾔中的⼀切操作都是基于内存的。
(2)变量和数组都是内存的别名。
①内存分配由编译器在编译期间决定②定义数组的时候必须指定数组长度③数组长度是在编译期就必须确定的(3)但是程序运⾏的过程中,可能需要使⽤⼀些额外的内存空间2. malloc 和 free 函数(1)malloc 和 free ⽤于执⾏动态内存分配的释放(2)malloc 所分配的是⼀块连续的内存(3)malloc 以字节为单位,并且返回值不带任何的类型信息:void* malloc(size_t size);(4)free ⽤于将动态内存归还系统:void free(void* pointer);(5)_msize(void* pointer)可以获取 malloc 出来的内存空间⼤⼩3. 使⽤ malloc 和 free 需要注意的地⽅(1)malloc 和 free 是库函数,⽽不是系统调⽤(2)malloc 实际分配的内存可能有会⽐请求的多,但不能依赖于不同平台下的 malloc ⾏为。
(3)当请求的动态内存⽆法满⾜时,malloc 返回 NULL(4)当 free 的参数为 NULL 时,函数直接返回malloc(0)返回什么?#include <stdio.h>#include <malloc.h>int main(){int i=10;int* p= NULL;for(i=0;i<100;i++){//注意，malloc(0)会返回⼀个有效的内存地址，⼤⼩为1//但我们不能依赖编译器的这种⾏为来使⽤这个字节的空间！p = (int*)malloc(i);printf("%d ",_msize(p));//返回malloc出来的内存空间⼤⼩free(p);}return 0;}内存泄漏检测模块mleak.h#ifndef _MLEAK_H_#define _MLEAK_H_#include <stdio.h>#include <malloc.h>#define MALLOC(n) mallocEx(n, __FILE__, __LINE__)#define FREE(p) freeEx(p)void* mallocEx(size_t n, const char* file, const line);void freeEx(void* p);void PRINT_LEAK_INFO();#endifmleak.c复制代码#include "mleak.h"#define SIZE 256//动态内存申请参数结构体typedef struct{void* pointer;//申请到的内存地址int size; //内存块⼤⼩const char* file; //⽂件名int line; //⽂件⾏号}MItem;static MItem g_record[SIZE]; //记录每个动态内存申请的操作void* mallocEx(size_t n, const char* file, const line){int i = 0;void* ret = malloc(n);//动态内存申请if(ret != NULL){//申请成功，则记录下来//遍历全局数组，记录此次操作for(i = 0; i< SIZE; i++){//查找位置if(g_record[i].pointer == NULL){g_record[i].pointer = ret;g_record[i].size = n;g_record[i].file = file;g_record[i].line = line;break;}}}return ret;}void freeEx(void* p){if(p != NULL){int i = 0;//遍历全局数组，释放内存空间，并清除操作记录for(i = 0; i< SIZE; i++){if(g_record[i].pointer == p){g_record[i].pointer = NULL;g_record[i].size = 0;g_record[i].file = NULL;g_record[i].line = 0;free(p);break;}}}}void PRINT_LEAK_INFO(){int i = 0;printf("Potenital Memory Leak Info:\n");//遍历全局数组，打印未释放的空间的申请记录for(i = 0; i< SIZE; i++){//查找位置if(g_record[i].pointer != NULL){printf("Address:%p, size:%d, Location:%s:%d\n",g_record[i].pointer,g_record[i].size,g_record[i].file,g_record[i].line);}}}testc.#include <stdio.h>#include "mleak.h"void f(){//没释放，会造成内存泄漏！MALLOC(100);}int main(){int* p = (int*)MALLOC(3 * sizeof(int));f();p[0] = 1;p[1] = 2;p[2] = 3;FREE(p);PRINT_LEAK_INFO();return 0;}/*输出结果：E:\Study>gcc test.c mleak.cE:\Study>a.exePotenital Memory Leak Info:Address:00602ED8, size:100, Location:38-1.c:7*/4. calloc 和 realloc 函数(1)malloc 的同胞兄弟:void* calloc(size_t num, size_t size);void* realloc(void* pointer,size_t new_size);(2)calloc 参数表⽰要返回 num 个某种类型(如 sizeof(int))⼤⼩的内存空间。