c语言数组的动态分配
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语言数组函数的使用方法1. 介绍C语言是一种广泛应用于系统开发、嵌入式设备、游戏开发等领域的编程语言。
在C语言中，数组是一种特殊的数据结构，它可以容纳多个相同类型的元素，并通过索引来访问和操作这些元素。
函数是C语言中的重要概念，它可以使程序模块化并提高代码的可读性和复用性。
本文将介绍C语言中数组函数的使用方法。
2. 定义和初始化数组定义数组是指给数组分配内存空间，并为数组元素指定类型。
C语言中，可以使用以下语法来定义一个数组：<数据类型> <数组名>[<数组大小>];例如，定义一个包含5个整数的数组：int numbers[5];数组的大小指定了数组可以容纳的元素个数。
数组的索引从0开始，因此上述数组的索引范围是0到4。
进行数组初始化可以分为两种情况：2.1 静态初始化静态初始化是指在定义数组时直接给数组元素赋初值。
例如，下面的代码定义并初始化了一个包含5个整数的数组：int numbers[5] = {1, 2, 3, 4, 5};上述代码将数组的前5个元素分别赋值为1、2、3、4和5。
2.2 动态初始化动态初始化是指在定义数组后，通过循环或用户输入等方式给数组元素赋值。
例如，下面的代码定义了一个包含5个整数的数组，并通过循环给数组元素赋值：int numbers[5];int i;for (i = 0; i < 5; i++) {numbers[i] = i + 1;}上述代码通过循环将数组的前5个元素分别赋值为1、2、3、4和5。
3. 数组函数的定义和使用数组函数是指以数组为参数和/或返回值的函数。
在C语言中，可以通过以下方式定义数组函数：<返回类型> <函数名>(<数据类型> <数组名>[<数组大小>]) {// 函数体}下面是一个示例，定义了一个数组函数用于计算数组中所有元素的和：int sum(int numbers[], int size) {int result = 0;int i;for (i = 0; i < size; i++) {result += numbers[i];}return result;}上述代码定义了一个名为sum的函数，接受一个整数数组和数组大小作为参数，并返回数组元素的和。
c语言动态分配的用法
c语言动态分配的用法C语言中，动态内存分配是通过使用malloc、calloc和realloc等函数来实现的。
动态分配内存可以根据程序运行时的需要来动态分配和释放内存空间，提高程序的灵活性和效率。
1. malloc函数：用于在堆（heap）中分配指定大小的内存空间。
其函数原型为void* malloc(size_t size)，其中size为要分配的内存空间的大小（以字节为单位）。
例如，以下代码动态分配了一个包含5个整数的整型数组的内存空间，并将其地址赋给指针变量p：```cint* p = (int*)malloc(5 * sizeof(int));```2. calloc函数：用于在堆中分配指定数量和大小的连续内存空间，并将其初始化为零值。
其函数原型为void* calloc(size_t num,size_t size)，其中num为要分配的元素个数，size为每个元素的大小。
例如，以下代码动态分配了一个包含5个整数的整型数组的内存空间，并将其地址赋给指针变量p：```cint* p = (int*)calloc(5, sizeof(int));```3. realloc函数：用于重新分配已分配内存空间的大小。
其函数原型为void* realloc(void* ptr, size_t size)，其中ptr为指向已分配内存空间的指针，size为重新分配的内存空间的大小。
例如，以下代码将已分配内存空间的大小重新设置为10个整数，并将其地址赋给指针变量p：```cint* p = (int*)malloc(5 * sizeof(int));int* q = (int*)realloc(p, 10 * sizeof(int));if (q != NULL) {p = q;}```4. free函数：用于释放由malloc、calloc和realloc函数分配的内存空间。
其函数原型为void free(void* ptr)，其中ptr为指向要释放的内存空间的指针。
c语言字符串数组定义的几种方式
C语言中，字符串数组是一个很常见的数据类型。
在定义字符串数组的过程中，有几种方式可以使用，每种方式都有其特点和适用场景。
接下来，我将从浅入深地介绍这几种方式，并对其进行全面评估。
1. 使用字符数组来定义字符串数组在C语言中，可以使用字符数组来定义字符串数组。
例如：```char strArray[3][20] = {"hello", "world", "c语言"};```这种方式是最基础的定义字符串数组的方法。
它的优点是简单直接，容易理解和使用，适用于简单的场景。
但缺点是不够灵活，每个字符串的长度都是固定的，不能动态调整。
2. 使用指针数组来定义字符串数组除了使用字符数组，还可以使用指针数组来定义字符串数组。
例如：```char *strArray[3] = {"hello", "world", "c语言"};```这种方式相比于字符数组更加灵活，每个字符串的长度可以动态调整。
但要注意的是，需要手动管理每个字符串的内存空间，避免出现内存泄漏等问题。
3. 动态分配内存来定义字符串数组另一种方式是动态分配内存来定义字符串数组。
这种方式可以在运行时动态申请和释放内存，非常灵活。
例如：```char **strArray;strArray = (char **)malloc(3 * sizeof(char *));for (int i = 0; i < 3; i++) {strArray[i] = (char *)malloc(20 * sizeof(char));}strcpy(strArray[0], "hello");strcpy(strArray[1], "world");strcpy(strArray[2], "c语言");```这种方式虽然灵活，但需要手动管理内存，容易出现内存泄漏和指针错误等问题，需要谨慎使用。
C语言中实现动态分配二维数组
C语言中实现动态分配二维数组在C语言中，要实现动态分配二维数组，可以使用指针的指针，或者使用一维指针，并进行适当的索引计算。
1.使用指针的指针：首先，需要定义一个指向指针的指针，如int **arr;然后，通过malloc函数动态分配内存，并为每一行分配内存空间：int rows = 5; // 指定二维数组的行数int cols = 4; // 指定二维数组的列数//为指针的指针分配内存空间arr = (int **)malloc(rows * sizeof(int *));for (int i = 0; i < rows; i++)arr[i] = (int *)malloc(cols * sizeof(int)); // 为每一行分配内存空间动态分配二维数组完成后，就可以通过索引来访问和操作数组元素：arr[2][3] = 10; // 修改第3行第4列的元素的值注意，当不再需要使用动态分配的二维数组时，应及时释放内存空间：for (int i = 0; i < rows; i++)free(arr[i]); // 释放每一行的内存空间free(arr); // 释放指针的指针的内存空间2.使用一维指针并进行适当的索引计算：首先，需要定义一个指向int类型的指针，如int *arr;然后，通过malloc函数动态分配内存，并计算出每行的起始位置：int rows = 5; // 指定二维数组的行数int cols = 4; // 指定二维数组的列数//为一维指针分配内存空间arr = (int *)malloc(rows * cols * sizeof(int));动态分配二维数组完成后，可以通过索引计算来访问和操作数组元素：arr[row * cols + col] = 10; // 修改第row行第col列的元素的值同样地，当不再需要使用动态分配的二维数组时，应及时释放内存空间：free(arr); // 释放一维指针的内存空间以上就是在C语言中实现动态分配二维数组的两种常用方法。
C语言中动态分配二维数组
}
for(i=0;i<n1;i++)
{
for(j=0;j<n2;j++)
{
for(k=0;k<n3;k++)
free(array[i][j][k]);//释放第四维指针
}
}
for(i=0;i<n1;i++)
{
for(j=0;j<n2;j++)
{
free(array[i][j]);//释放第三维指针
}
} array[][][]（整型常量）
当然，你可以把它们整合在一起为：
int i,j,k;
int n1,n2,n3;
int ***array;
scanf("%d%d%d",&n1,&n2,&n3);
array=(int***)calloc(n1,sizeof(int**));
for(i=0;i<n1;i++)
for(k=0;k<n3;k++)
{
array[i][j][k]=i+j+k+1;
printf("%d\t",array[i][j][k]);
}
puts("");
}
puts("");
}
for(i=0;i<n1;i++)
{
for(j=0;j<n2;j++)
{
free(array[i][j]);//释放第三维指针
ccs动态内存分配
int i; for(i=0; i i++) a[i] = (char *)malloc(sizeof(char) * n); printf( %d\n , sizeof(a));//4*M，指针数组 printf( %d\n , sizeof(a[0]));//4，指针 for(i=0; i i++) free(a[i]); (3)已知第一维，一次分配内存(保证内存的连续性) Code-3 char* a[M];//指针的数组 int i; a[0] = (char *)malloc(sizeof(char) * M * n); for(i=1; i i++) a[i] = a[i-1] + n; printf( %d\n , sizeof(a));//4*M，指针数组 printf( %d\n , sizeof(a[0]));//4，指针 free(a[0]); (4)两维都未知 Code-4 char **a; int i; a = (char **)malloc(sizeof(char *) * m);//分配指针数组 for(i=0; i i++) { a[i] = (char *)malloc(sizeof(char) * n);//分配每个指针所指向的数组 } printf( %d\n , sizeof(a));//4，指针 printf( %d\n , sizeof(a[0]));//4，指针 for(i=0; i i++) { free(a[i]); } free(a); (5)两维都未知，一次分配内存(保证内存的连续性)
最后用 for(i=0;i 就可以了 (2)、int *Ptr[ 5 ] 这样定义的话， 编译器已经为它分配了 5 个指针的空间，这相当于(1)中的第 一次内存分配。根据对(1)的讨论可知，显然要对其进行一次内存分配的。否则 就是 野 指针。 (3)、int ( *Ptr )[ 5 ] 这种定义我觉得很费解，不是不懂，而是觉得理解起来特别吃力，也许是我不 太习惯这样的定义吧。 怎么描述它呢？它的意义是 一群 指针，每个指针都是指 向一个 5 个整数的数组。 如果想分配 k 个指针，这样写： Ptr = ( int ( * )[ 5 ] ) new int[ 5 * k ]。 这是一次性的内存分配。分配好以后，Ptr 指向一片连续的地址空间， 其中 Ptr[ 0 ] 指向第 0 个 5 个整数数组的首地址，Ptr[ 1 ] 指向第 1 个 5 个整数数组的首地址。 综上所述，我觉得可以这样理解它们： int ** Ptr == int Ptr[ x ][ y ]; int *Ptr[ 5 ] == int Ptr[ 5 ][ x ]; int ( *Ptr )[ 5 ] == int Ptr[ x ][ 5 ]; 这里 x 和 y 是表示若干的意思。 _______________________________________________________________ 1. C 语言动态分配二维数组 (1)已知第二维 Code-1 char (*a)[N];//指向数组的指针 a = (char (*)[N])malloc(sizeof(char *) * m); printf( %d\n , sizeof(a));//4，指针 printf( %d\n , sizeof(a[0]));//N，一维数组 free(a); (2)已知第一维 Code-2 char* a[M];//指针的数组 cfree(a[i]); cfree(a);释放内存
C语言技术的高级使用方法
C语言技术的高级使用方法C语言作为一门广泛应用于软件开发和系统编程的编程语言，其高级使用方法在提高代码效率和性能方面起着重要作用。
本文将探讨几种C语言技术的高级使用方法，包括指针操作、内存管理以及多线程编程。
一、指针操作指针是C语言中一种强大的工具，可以直接访问和操作内存中的数据。
高级使用方法包括指针的指针、指针的算术运算以及函数指针等。
1. 指针的指针指针的指针是指指针变量的地址存储在另一个指针变量中。
通过使用指针的指针，可以实现多级间接访问，提高代码的灵活性和效率。
例如，可以使用指针的指针来实现动态数组的分配和释放。
通过在堆上分配一块内存，并将其地址存储在指针的指针中，可以实现动态数组的大小调整。
2. 指针的算术运算指针的算术运算允许对指针进行加减运算，以及比较大小。
这在处理数组和字符串时非常有用。
例如，可以使用指针的算术运算来实现字符串的逆序输出。
通过将指针指向字符串的末尾，然后逐步向前移动指针，可以实现字符串的逆序输出。
3. 函数指针函数指针是指向函数的指针变量。
通过使用函数指针，可以实现回调函数和动态函数调用等高级功能。
例如，可以使用函数指针来实现回调函数，即将一个函数作为参数传递给另一个函数。
这在事件处理和异步编程中非常有用。
二、内存管理C语言中的内存管理是一项关键任务，直接影响程序的性能和稳定性。
高级使用方法包括动态内存分配、内存池和内存映射文件等。
1. 动态内存分配动态内存分配允许在程序运行时分配和释放内存。
通过使用动态内存分配函数（如malloc和free），可以根据需要动态调整内存的大小。
例如，可以使用动态内存分配来实现链表数据结构。
通过在每个节点中使用指针来指向下一个节点，可以实现动态增删节点的功能。
2. 内存池内存池是一种预先分配一定数量内存块的技术。
通过使用内存池，可以减少动态内存分配和释放的次数，提高程序的效率。
例如，可以使用内存池来管理大量的小对象。
通过将内存分为固定大小的块，并将这些块链接在一起，可以实现高效的内存分配和释放。
c语言二维动态数组的定义
c语言二维动态数组的定义摘要：1. C 语言二维动态数组的概念2. C 语言二维动态数组的定义方法3. C 语言二维动态数组的使用示例4. C 语言二维动态数组的优缺点正文：C 语言二维动态数组是指在程序运行过程中，可以根据需要动态分配空间，并且可以随时改变其大小的二维数组。
这种数组相比于普通的二维数组，更加灵活，能够适应不同的程序需求。
下面，我们将详细介绍C 语言二维动态数组的定义方法，使用示例以及其优缺点。
一、C 语言二维动态数组的定义方法在C 语言中，二维动态数组需要使用指针来定义。
其定义方法如下：```cint **动态数组名;```这里，`动态数组名`是指向指针的指针，通过这个指针，我们可以间接地操作二维动态数组。
二、C 语言二维动态数组的使用示例下面，我们将通过一个简单的示例来说明如何使用二维动态数组：```c#include <stdio.h>#include <stdlib.h>int main(){int **动态数组;int row, col;// 动态分配数组空间dynamic 数组= (int **)malloc(sizeof(int *));if (dynamic 数组== NULL){printf("内存分配失败");return 0;}// 设置数组大小row = 10;col = 20;// 初始化数组元素for (int i = 0; i < row; i++){dynamic 数组[i] = (int *)malloc(sizeof(int) * col);if (dynamic 数组[i] == NULL){printf("内存分配失败");return 0;}for (int j = 0; j < col; j++){scanf("%d", &dynamic 数组[i][j]);}}// 输出数组元素for (int i = 0; i < row; i++){for (int j = 0; j < col; j++){printf("%d ", dynamic 数组[i][j]);}printf("");}// 释放数组空间for (int i = 0; i < row; i++){free(dynamic 数组[i]);}free(dynamic 数组);return 0;}```在这个示例中，我们首先通过`malloc`函数动态分配了一块内存，作为二维动态数组的首地址。
c语言可变数组
c语言可变数组
1 什么是C语言可变数组
C语言可变数组是指C语言中可以在程序运行过程中改变数组长度的数据结构。
特别是当我们给定一个特定大小时，C语言普通数组类型在运行期间无法更改其大小。
C语言可变数组是一种内存管理技术，可以在运行期间动态更改数组大小，并保持数组的长度和数据的一致性。
2 C语言可变数组的特性
1. 分配存储器：C语言可变数组可以在程序运行期间动态分配一
定的内存来存放数据，并且可以根据程序的需要随时扩展或缩小存储
空间。
2. 节省内存空间：使用C语言可变数组可以有效地节省内存空间，因为只有在运行时，才会分配空间到内存中，而不是编译时就分配空间。
3. 增加程序的灵活性：C语言可变数组提供了一种灵活的模型，
可以在程序运行期间动态更改数组大小，并保持数据的一致性。
3 用法介绍
C语言可变数组提供了一种灵活的内存管理方式，可以把程序中的可变长度数据结构进行动态更新和维护。
与其他静态数据结构（如数组）相比，可变数组的存储需求更小，可以更有效地节省空间。
C语言可变数组的实现有多种方法，比如重新分配内存，使用vector容器等，要根据实际的业务需求而定。
重新分配内存在速度上会更快，但不易于恢复，使用vector容器比较简单，但在性能上会稍微低一些。
4 小结
C语言可变数组是一种内存管理技术，可以方便地在程序运行期间动态更改数组大小和保持数据的一致性。
C语言可变数组的最大优点是可以有效节省存储空间。
在使用C语言可变数组时，可以根据实际需要使用重新分配内存等多种方法，以便更好地维护和更新可变数组。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
下面代码添加到头文件里面#include<stdio.h>#include<stdlib.h>struct data{int*p;//指针保存数组起始点int length;//保存数组长度int reallength;//实际分配内存长度int state;//0代表无序，1代表有序从小到大，2代表有序从大到小};struct find{int**pp;int n;};void init(struct data*pdata);//初始化void reinit(struct data*pdata);//重新初始化void addobject(struct data*pdata,int num);//增加一个元素void addobjects(struct data*pdata,int*pnum,int n);//增加一个数组void printf1(struct data*pdata);//打印一个出来void sort(struct data*pdata,int obj);//实现排序obj=0从小到大，否则从大到小int*finddata(struct data*pdata,int num);//找到并返回第一次找到的地址void change(struct data*pdata,int oldnum,int newnum);//修改一个数据void insert(struct data*pdata,int num,int insertnum,int headback);//插入一个数据，0代表前插，1代表后插void deleteone(struct data*pdata,int num);//删除第一个找到的数据void deleteall(struct data*pdata,int num);//删除找到的全部数据struct find findalldata(struct data*pdata,int num);//返回一片内存，包含所有找到的元素添加到源文件中#include<stdio.h>#include<stdlib.h>#include"动态数组.h"void init(struct data*pdata){pdata->p=NULL;pdata->length=0;pdata->reallength=0;pdata->state=0;}void reinit(struct data*pdata){if(pdata->p==NULL){return;}else{free(pdata->p);pdata->p=NULL;pdata->length=0;pdata->reallength=0;pdata->state=0;}}void addobject(struct data*pdata,int num){if(pdata->p==NULL){pdata->p=(int*)malloc(sizeof(int));*(pdata->p)=num;pdata->length++;pdata->reallength++;}else{if(pdata->length==pdata->reallength){(pdata->length)++;(pdata->reallength)++;pdata->p=(int*)realloc(pdata->p,(pdata->length)*sizeof(int));pdata->p[pdata->length-1]=num;}else{(pdata->length)++;pdata->p[pdata->length-1]=num;}}}void addobjects(struct data*pdata,int*pnum,int n){if(pdata->p==NULL){pdata->p=(int*)malloc(sizeof(int)*n);for(int i=pdata->length;i<pdata->length+n;i++){pdata->p[i]=pnum[i];}pdata->length+=n;pdata->reallength+=n;}else{if(pdata->length+n<=pdata->reallength){for(int i=pdata->length;i<pdata->length+n;i++){pdata->p[i]=pnum[i-pdata->length];}(pdata->length)+=n;}else{pdata->p=(int*)realloc(pdata->p,(pdata->length+ n)*sizeof(int));for(int i=pdata->length;i<pdata->length+n;i++){pdata->p[i]=pnum[i-pdata->length];}(pdata->length)+=n;(pdata->reallength)+=n;}}}void printf1(struct data*pdata){if(pdata->p==NULL){printf("打印失败\n");}else{for(int i=0;i<pdata->length;i++){printf("%d\n",pdata->p[i]);}printf("动态数组长度为%d\n",pdata->length);}}void sort(struct data*pdata,int obj){if(obj==0)//从小到大{for(int i=0;i<pdata->length-1;i++){for(int j=0;j<pdata->length-1-i;j++){if(pdata->p[j]>pdata->p[j+1]){pdata->p[j]=pdata->p[j]^pdata->p[j+1];pdata->p[j+1]=pdata->p[j]^pdata->p[j+1];pdata->p[j]=pdata->p[j]^pdata->p[j+1];}}}pdata->state=1;}else//从小到大{for(int i=0;i<pdata->length-1;i++){for(int j=0;j<pdata->length-1-i;j++){if(pdata->p[j]<pdata->p[j+1]){pdata->p[j]=pdata->p[j]^pdata->p[j+1];pdata->p[j+1]=pdata->p[j]^pdata->p[j+1];pdata->p[j]=pdata->p[j]^pdata->p[j+1];}}}pdata->state=2;}}int*finddata(struct data*pdata,int num){if(pdata->state==0){for(int i=0;i<pdata->length;i++){if(pdata->p[i]==num){return&pdata->p[i];break;}}//printf("此数据不存在\n");return NULL;}else if(pdata->state==1){int low=0;int high=pdata->length-1;int mid=(low+high)/2;while(low<=high){if(pdata->p[mid]==num){return&pdata->p[mid];}else if(pdata->p[mid]>num){high=mid-1;mid=(low+high)/2;}else{low=mid+1;mid=(low+high)/2;}}// printf("此数据不存在\n");return NULL;}else{int low=0;int high=pdata->length-1;int mid=(low+high)/2;while(low<=high){if(pdata->p[mid]==num){return&pdata->p[mid];}else if(pdata->p[mid]>num){low=mid+1;mid=(low+high)/2;}else{high=mid-1;mid=(low+high)/2;}}// printf("此数据不存在\n");return NULL;}}void change(struct data*pdata,int oldnum,int newnum){int*p=finddata(pdata,oldnum);if(p==NULL){printf("查找失败，没有修改的这个数");return;}else{*p=newnum;}}void insert(struct data*pdata,int num,int insertnum,int headback) {int*curposition=finddata(pdata,num);if(curposition==NULL){printf("查找失败，没有像插入的这个数");return;}else{if(headback==0){if(pdata->length==pdata->reallength){int cur=curposition-pdata->p;pdata->p=(int*)realloc(pdata->p,(pdata->length+ 1)*sizeof(int));for(int i=pdata->length-1;i>=cur;i--){pdata->p[i+1]=pdata->p[i];}pdata->p[cur]=insertnum;pdata->length++;pdata->reallength++;}else{int cur=curposition-pdata->p;for(int i=pdata->length-1;i>=cur;i--){pdata->p[i+1]=pdata->p[i];}pdata->p[cur]=insertnum;pdata->length++;}}else//后面插入{if(pdata->length==pdata->reallength){int cur=curposition-pdata->p;pdata->p=(int*)realloc(pdata->p,(pdata->length+ 1)*sizeof(int));for(int i=pdata->length-1;i>cur;i--){pdata->p[i+1]=pdata->p[i];}pdata->p[cur+1]=insertnum;pdata->length++;pdata->reallength++;}else{int cur=curposition-pdata->p;for(int i=pdata->length-1;i>cur;i--){pdata->p[i+1]=pdata->p[i];}pdata->p[cur+1]=insertnum;pdata->length++;}}}}void deleteone(struct data*pdata,int num){if(pdata->p==NULL){printf("删除失败\n");return;}else{int*curposition=finddata(pdata,num);int cur=curposition-pdata->p;for(int i=cur;i<pdata->length-1;i++){pdata->p[i]=pdata->p[i+1];}pdata->length-=1;}}void deleteall(struct data*pdata,int num){if(pdata->p==NULL){printf("删除失败\n");return;}else{while(finddata(pdata,num)){deleteone(pdata,num);}}}int*find(int*p,int num,int n){for(int i=0;i<n;i++){if(p[i]==num){return p+i;break;}}return NULL;}struct find findalldata(struct data*pdata,int num){struct find resn;if(pdata->p==NULL){printf("查找失败\n");resn.n=0;resn.pp=NULL;return resn;}else{int tem=0;for(int*pp=find(pdata->p,num,pdata->length);pp!=NULL;pp= find(pp+1,num,pdata->length-(pp-pdata->p))){tem++;}resn.n=tem;int**p1=(int*)malloc(sizeof(int*)*tem);resn.pp=p1;for(int*pp=find(pdata->p,num,pdata->length),j=0;pp!=NULL; j++,pp=find(pp+1,num,pdata->length-(pp-pdata->p))){p1[j]=pp;//printf("%p,%d\n", p1[j], *p1[j]);}return resn;}}。