开发者社区> 吴英强> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

【C/C++学院】0828-数组与指针/内存分配/数据结构数组接口与封装

简介: <p><strong><span style="color:#3366ff">【送给在路上的程序员】</span></strong></p> <p><strong><span style="color:#cc0000">对于一个开发者而言,能够胜任系统中任意一个模块的开发是其核心价值的体现。</span></strong></p> <p><strong><span style="col
+关注继续查看

【送给在路上的程序员】

对于一个开发者而言,能够胜任系统中任意一个模块的开发是其核心价值的体现。

对于一个架构师而言,掌握各种语言的优势并可以运用到系统中,由此简化系统的开发,是其架构生涯的第一步。

对于一个开发团队而言,能在短期内开发出用户满意的软件系统是起核心竞争力的体现。

每一个程序员都不能固步自封,要多接触新的行业,新的技术领域,突破自我。


数组与指针

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

void main1()
{
	int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	for (int *p = a; p < a + 10; p++)//指针类型决定占4个字节
	{
		printf("\n%p,%d", p, *p);
	}

	getchar();
}

void  main2()
{
	//轮询数组的时候,用指针轮询,指针可以指向某个元素的大小
	//指针数组,管理地址,按照顺序执行指令
	char *str[5] = { "calc", "notepad", "tasklist", "pause", "mspaint" };
	for (char **pp = str; pp < str + 5; pp++)//
	{
		system(*pp);
	}
}

void  main3()
{
	char str[5][10] = { "calc", "notepad", "tasklist", "pause", "mspaint" };
	printf("%p", str);
	 //p[1],p[2],p[3]
	//类型不一样
	for (char(*p)[10] = str; p < str + 5; p++)
	{
		printf("\n %p,%s", p, p);//打印地址  字符串
		system((char *)p);
	}

	//char **pp = str;
	//for (char **pp = str; pp < str + 5; pp++)//
	//{
	//	system(*pp);
	//}
	system("pause");
}

void  main4()
{
	char str[5][10] = { "calc", "notepad", "tasklist", "pause", "mspaint" };
	printf("%p,%p,%p", str, &str, *str);
	//指针地址的一样,但是类型不一样
	//str代表行地址,&str代表整个数组的地址,*str就是第一个字符的地址

	printf("\n%d,%d,%d", sizeof(*str), sizeof(*(&str)), sizeof(*(*str)));
	////求指针指向内容占多大
	//int num = 10;
	//int *p1=#
	//double db = 10.9;
	//double *  p2 = &db;
	//printf("%d,%d", sizeof(p1), sizeof(p2));
	//printf("\n%d,%d", sizeof(*p1), sizeof(*p2));
	system("pause");
}

void main5()
{
	int a[3][4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
	printf("%p\n", a);
	//int *p1 = &a[0][0];
	//int *p2 = p1 + 4;
	//printf("%d", *p2);
	//int *p3 = p2 - 3;
	//printf("\n%d", *p3);
	//printf("\n%d", p2 - p3); 
	////C语言运算规则,加法加上元素的大小×加上的数
	////减法就是减去元素的大小×减去的数
	////int *p=0x300500    p+2*(sizeof(int))=0x300508
	////char *p1=0x300500    p1+2*(sizeof(char))=0x300502
	for (int *p = &a[0][0]; p < &a[0][0] + 12; p++)
	{	
		if ((p - &a[0][0])%4 == 0)
		{
			printf("\n");
		}
		printf("%5d", *p);
	}
	printf("\n\n\n");
	int (*px)[4] = a;//a是一个常量的行指针,a的类型与px等价的
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			//printf("%5d", a[i][j]);
			//printf("%5d", px[i][j]);
			//printf("%5d", *(px[i] + j));
			printf("%5d", *(*(px + i) + j));
		}
		printf("\n");
	}

	getchar();
}

数组与指针2

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

int  searchmax(int a[3][4])//一维数组没有副本机制,二维数组也没有,数组作为参数都是传递地址
{

	//printf("\nsearch=%d", sizeof(a));//
	//int b[3][4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2 };
	//printf("\nsaerch b=%d", sizeof(b));
	int max;//存储最大的值
	max = a[0][0];
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			if (a[i][j]>max)//比较大小
			{
				max = a[i][j];//接受最大的地址
			}
		}
	}
	return max;
}

int  searchmaxA(int (*p)[4])//退化为一个指向有四个元素的数组的哦指针
{
	//printf("\nsearch=%d", sizeof(a));//
	//int b[3][4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2 };
	//printf("\nsaerch b=%d", sizeof(b));
	int max;//存储最大的值
	max = p[0][0];
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			if (p[i][j]>max)//比较大小
			{
				max = p[i][j];//接受最大的地址
			}
		}
	}
	return max;
}

int  searchmin(int(*p)[4])
{
	//int  min = p[0][0];//假定第一个是最小的
	int  min = *(*(p+0)+0);//第一个元素的大小

	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			//if (p[i][j]<min)//比较大小
			//{
			//	min= p[i][j];//求出最小的数
			//}
			if (*(*(p + i) + j) < min)
			{
				min = *(*(p + i) + j);
			}

		}
	}

	return   min;
}


void main4()
{
	int a[3][4] = { 1, 2, 3, 4, 5, 16, -7, 8, 9, 10, 1, 2 };
	printf("\nmain=%d", sizeof(a));//
	//printf("\n%d",searchA(a));//退化为一个指针
	printf("\n%d", searchmin(a));

	system("pause");
}

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

struct pos
{
	int x;
	int y;
};

//struct pos  pos1[8] = { { 100, 200 },
//{ 100, 0 },
//{ 200, 400 } ,
//{300,400},
//{390,600},
//{ 190, 900 },
//{ 990, 100 },
//{ 1390, 600 }
//};
struct pos  pos1[8][2] = { { { 100, 200 }, { 1000, 900 } },
{ { 200, 0 }, { 900, 800 } },
{ { 0, 0 }, { 800, 1300 } },
{ { 1500, 200 }, {600, 900 } },
{ { 800, 700 }, { 700, 800 } },
{ { 300, 100 }, { 600, 700 } },
{ { 900, 800 }, { 700, 700 } },
{ { 100, 200 }, { 800, 800 } },
};

void mainx()
{
	HWND *win = FindWindowA("Notepad", "无标题 - 记事本");
	if (win == NULL)
	{
		return;
	}
	SetWindowPos(win, NULL, 0, 0, 100, 300, 1);
	for (int i = 0; i < 8; i++)
	{
		//设置窗口位置大小
		SetWindowPos(win, NULL, pos1[i][0].x, pos1[i][0].y, pos1[i][1].x, pos1[i][1].y, 1);
		Sleep(3000);
	}

	system("pause");
}

三维数组

#include<stdio.h>
#include<stdlib.h>
//int a [10]  int *p
//int a[10][9] int (*p)[9]
//int  a[8]  [9][10]   int (*p)[9][10]

void print3(int a[3][4][5])
{
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			for (int k = 0; k < 5; k++)
			{
				printf("%4d", a[i][j][k]);
			}
			printf("\n");
		}
		printf("\n\n\n");
	}
}

void print3A(int (*p)[4][5])//指针的方式
{
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			for (int k = 0; k < 5; k++)
			{
				//printf("%4d", p[i][j][k]);
				//指针访问三维数组
				printf("%4d", *(*(*(p + i) + j) + k));

			}
			printf("\n");
		}
		printf("\n\n\n");
	}
}

void main()
{
	int a[3][4][5];
	int num = 0;
	printf("%d\n", sizeof(a));
	//线性初始化
	for (int *p = &a[0][0][0]; p < &a[0][0][0] + 60; p++)
	{
		*p = num;
		num++;
	}
	//int(*px)[4][5] = a;//等价关系	
	print3A(a);
	getchar();
}

内存分配

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

void main1()
{
	int a[1024 * 1024];//栈溢出
	int num = 100;
	//int a[num];VC数组必须常量,GCC可以是变量
}
//增加,删除,查询,修改
int a[10];
int length=10;

void main2()
{
	for (int i = 0; i < length; i++)
	{
		printf("%d\n", a[i] = i);//初始化数组并打印
	}

	int num = 3;
	if (a[length - 1] == num)//判定最后一个
	{
		length -= 1;//长度递减
	}
	else
	{
		for (int i = 0; i < length - 1; i++) //遍历数组
		{
			if (num == a[i])//找到
			{

				for (int j = i; j < length-1; j++)//删除
				{
					a[j] = a[j + 1];//从后往前移动
				}
				length = length - 1;//长度-1
				break;
			}
		}

	}
	for (int i = 0; i < length; i++)
	{
		printf("%d\n", a[i] );//数组并打印
	}
	system("pause");
}

void  main3()
{
	int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	//写C程序的时候,务必保证绝对不出错误,偶尔不报错
	a[10] = 11;
	a[11] = 12;
	a[102345] = 123;

	getchar();
}

void  main()
{
	int  *p1 = (int*)malloc(sizeof(int)* 10);//只管分配,不初始化
	int *p2 = (int *)calloc(10,sizeof(int));//calloc会进行内存清零
	printf("%p,%p", p1, p2);

	for (int i = 0; i < 10; i++)
	{
		p1[i] = i;
		p2[i] = i;
	}
	getchar();
}

数据结构数组接口与封装

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

void main1()
{
	int  *p =(int *) calloc(10, sizeof(int));//分配内存
	printf("%p\n", p);//输出地址

	for (int i = 0; i < 10; i++)
	{
		*(p + i) = i;//*(p+i)等价于p[i]
	}

	int *pnew = (int *)realloc(p, 100000);//变长
	//realloc.第一种情况,后面的内存没人用,就直接拓展变长
	//第二种情况,后面的内存有人用,先分配新的长度,拷贝原来的内存,释放的原来的内存
	printf("%p", pnew);

	for (int i = 10; i < 25000; i++)
	{
		*(pnew + i) = i;
	}

	system("pause");
}

动态数组

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

struct data
{
	int *p;//指针保存数组的起始点
	int length;//保存数组的长度
	int stat;//0代表无序,1代表有序从小到大,2有序从大到小
	int reallength;//实际分配的内存长度
};

struct findres
{
	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  printfall(struct data *pdata);//打印所有的数据
int  * finddata(struct data *pdata, int num);//返回第一个找到数据的地址
void  sort(struct data *pdata, int obj);//obj=0,从小大到,否则从到小
void  change(struct data *pdata, int oldnum, int newnum);//实现修改
void  deleteone(struct data *pdata, int num);//删除第一个找到的数据
void  deleteall(struct data *pdata, int num); //删除所有能找到的数据


struct findres findadlldata(struct data *pdata, int num);//返回一片内存,包含所有找到的元素的首地址
void  insert(struct data *pdata, int num, int insertnum, int headback);//数据插入
//1代表前面插入,0代表后面插入

#include"动态数组.h"

void init(struct data *pdata) //使用之前初始化
{
	
		pdata->p = NULL;//意味着还没有初始化
		pdata->length = 0;//长度为0;
		pdata->stat = 0;//代表无序
		pdata->reallength = 0;//实际长度
}

void  reinit(struct data *pdata)//使用之后
{
	if (pdata->p == NULL)
	{
		return;
	}
	else
	{
		free(pdata->p);//释放内存
		pdata->p = NULL;//意味着还没有初始化
		pdata->length = 0;//长度为0;
		pdata->stat = 0;//代表无序
		pdata->reallength = 0;//实际长度
	}
}

//增加一个数据
void  addobject(struct data *pdata, int num)
{
	if (pdata->p == NULL)
	{
		pdata->p = (int *)malloc(sizeof(int));//增加一个元素
		pdata->length = 1;//数组标识增加一个元素
		pdata->reallength = 1;//实际长度
		pdata->p[pdata->length - 1] = num;//赋值
	}
	else
	{
		if (pdata->length == pdata->reallength)
		{
			pdata->p = (int *)realloc(pdata->p, (pdata->length + 1)*sizeof(int));
			pdata->length += 1;//数组标识增加一个元素
			pdata->reallength += 1;//实际长度
			pdata->p[pdata->length - 1] = num;//赋值
		}
		else
		{
			pdata->length += 1;//数组标识增加一个元素
			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);//增加N个元素
		pdata->length = n;//数组标识增加n个元素
		pdata->reallength = n;//实际长度
		for (int i = 0; i < n; i++)
		{
			pdata->p[i] = pnum[i];//拷贝数组
		}
	}
	else
	{
		if (pdata->length+n <= pdata->reallength)
		{
			for (int i = 0; i < n; i++)
			{
				pdata->p[i + pdata->length] = pnum[i];//拷贝数组
			}
			pdata->length += n;//数组标识增加n个元素
		}
		else
		{
			pdata->p = (int *)realloc(pdata->p, (pdata->length + n)*sizeof(int));//重新分配内存
			for (int i = 0; i < n; i++)
			{
				pdata->p[i + pdata->length] = pnum[i];//拷贝数组
			}
			pdata->length += n;//数组标识增加n个元素
			pdata->reallength += n;//增加长度
		}
	}
}


void  printfall(struct data *pdata) //打印所有的数组
{
	for (int i = 0; i < pdata->length; i++)
	{
		printf("%d\n", pdata->p[i]);//输出一个数组
	}
}

void  sort(struct data *pdata, int obj)//obj=0,从小大到,否则从da到小
{
	if (obj == 0)
	{
		for (int i = 0; i < pdata->length - 1; i++)
		{
			for (int j = 0; j < pdata->length - i-1; j++)
			{
				if (pdata->p[j] > pdata->p[j + 1])// j >j+1  
				{
					int temp = pdata->p[j]; //交换数据
					pdata->p[j] = pdata->p[j + 1];
					pdata->p[j + 1] = temp;
				}
			}
		}
		pdata->stat = 1;//代表从小到大
	}
	else
	{
		for (int i = 0; i < pdata->length - 1; i++)
		{
			for (int j = 0; j < pdata->length - i-1; j++)//冒泡没循环一次,沉底一个极值
			{
				if (pdata->p[j] < pdata->p[j + 1])// j <j+1  
				{
					//int temp = pdata->p[j]; //交换数据
					//pdata->p[j] = pdata->p[j + 1];
					//pdata->p[j + 1] = temp;
					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];
					//0011  0001  3  1
					//p[j]0011
					//p[j + 1]0001
					// p[j]   0010
					//p[j + 1]0001
					// p[j]   0010
					//p[j + 1]0011
					//        0001  a=a^b,b=a^b.a=a^b;
				}
			}
		}
		pdata->stat = 2;//代表从大到小
	}
}



int  * finddata(struct data *pdata, int num)
{
	if (pdata->stat == 0)
	{
		for (int i = 0; i < pdata->length; i++)//顺序循环
		{
			printf("查找第%d次\n", i);
			if (num == pdata->p[i])//判定是否相等
			{
				return  &pdata->p[i];//返回一个地址
				break;//跳出循环
			}
		}
		return NULL;
	}
	else if (pdata->stat == 1) //二分查找法//从小到da
	{
		int  shang = 0;//shang
		int xia = pdata->length - 1;//下
		while (shang <= xia)//循环终止条件, 
		{
			
			int zhong = (shang + xia) / 2;
			printf("%d,%d,%d\n", shang, zhong, xia);
			if (pdata->p[zhong] == num)
			{
				return  &pdata->p[zhong];//返回地址
			}
			else if (pdata->p[zhong] >num)
			{
				xia = zhong - 1;
			}
			else if (pdata->p[zhong]<num)
			{
				shang = zhong + 1;
			}
		}
		return NULL;

	}
	else
	{
		int  shang = 0;//shang
		int xia = pdata->length - 1;//下
		
		while (shang <= xia)//循环终止条件, 
		{
			int zhong = (shang + xia) / 2;
			printf("%d,%d,%d\n", shang, zhong, xia);
			if (pdata->p[zhong] == num)
			{
				return  &pdata->p[zhong];//返回地址
			}
			else if (pdata->p[zhong] >num)
			{
				//xia = zhong - 1;
				shang = zhong + 1;
			}
			else if (pdata->p[zhong]<num)
			{
				//shang = zhong + 1;
				xia = zhong - 1;
			}
		}
		return NULL;
	}
}

void  change(struct data *pdata, int oldnum, int newnum)//实现修改
{
	int *p = finddata(pdata, oldnum);
	if (p == NULL)
	{
		printf("修改失败,没有找到");
		return;
	}
	else
	{
		*p = newnum;//修改数据
	}
}

////1代表前面插入,0代表后面插入
void  insert(struct data *pdata, int num, int insertnum, int headback)//数据插入
{
	int *p = finddata(pdata, num);//查找数据
	if (p == NULL)
	{
		return ;//没有找到
	}
	else
	{
		//找到,前面插入 ,否则后面插入
		if (headback==1)
		{
			if (pdata->length<pdata->reallength)//不需要分配
			{
				int  curr = p - pdata->p;//获取要插入位置的下标
				for (int i = pdata->length - 1; i>=curr; i--)
				{
					pdata->p[i + 1] = pdata->p[i];//从后向前移动
				}
				pdata->p[curr] = insertnum;//实现插入,前面插入
				pdata->length++;//长度加1
			}
			else
			{
				int  curr = p - pdata->p;//获取要插入位置的下标
				pdata->p = (int *)realloc(pdata->p, (pdata->length + 1)*sizeof(int));//增加分配内存
				pdata->reallength++;//实际长度+1;
				for (int i = pdata->length - 1; i >= curr; i--)
				{
					pdata->p[i + 1] = pdata->p[i];//从后向前移动
				}
				pdata->p[curr] = insertnum;//实现插入,前面插入
				pdata->length++;//长度加1
			}
		}
		else
		{
			if (pdata->length<pdata->reallength)//不需要分配
			{
				int  curr = p - pdata->p;//获取要插入位置的下标
				for (int i = pdata->length - 1; i > curr; i--)//实现移动
				{
					pdata->p[i + 1] = pdata->p[i];//从后向前移动
				}
				pdata->p[curr+1] = insertnum;//实现插入,hou插入
				pdata->length++;//长度加1
			}
			else
			{
				int  curr = p - pdata->p;//获取要插入位置的下标
				pdata->p = (int *)realloc(pdata->p, (pdata->length + 1)*sizeof(int));//增加分配内存
				pdata->reallength++;//实际长度+1;
				for (int i = pdata->length - 1; i > curr; i--)//实现移动
				{
					pdata->p[i + 1] = pdata->p[i];//从后向前移动
				}
				pdata->p[curr + 1] = insertnum;//实现插入,hou插入
				pdata->length++;//长度加1
			}
		}
	}
}

//删除
void  deleteone(struct data *pdata, int num)
{
	int *p = finddata(pdata, num);//查找数据
	if (p == NULL)
	{
		return ;//没有找到,删除,
	}
	else
	{
		int  curr = p - pdata->p;//cur就是要删除的下标
		//printf("\n%d,%p", *p, p);
		//printf("\n%d,%p", pdata->p[curr], &pdata->p[curr]);//输出数据
		for (int i = curr; i < pdata->length - 1; i++)
		{
			pdata->p[i] = pdata->p[i + 1];//从后向前移动
		}
		pdata->length -= 1;//数组元素减去1
	}
}

//删除全部
void  deleteall(struct data *pdata, int num) //删除所有能找到的数据
{
	for (int *p = finddata(pdata, num); p != NULL; p = finddata(pdata, num))
	{
		int  curr = p - pdata->p;//cur就是要删除的下标
		//printf("\n%d,%p", *p, p);
		//printf("\n%d,%p", pdata->p[curr], &pdata->p[curr]);//输出数据
		for (int i = curr; i < pdata->length - 1; i++)
		{
			pdata->p[i] = pdata->p[i + 1];//从后向前移动
		}
		pdata->length -= 1;//数组元素减去1

	}
}

int * find(int *p, int num,int n )//从一个地址开始,N个范围之内找到
{
	for (int i = 0; i < n; i++)//循环
	{
		if (p[i] == num)//判断
		{
			return p + i;//返回找到的地址
			break;
		}
	}
	return NULL;//代表没有找到
}



struct findres findadlldata(struct data *pdata, int num)
{
	struct findres  res1;//构建结构体变量
	
	int i = 0; //统计找到多少个。
	for (int *p = find(pdata->p, num, pdata->length - 1);p!=NULL; p = find(p+1, num, (pdata->length - 1)-(p-pdata->p)))
	{
		i++;
	}
	res1.n = i;//长度
	int **pint = (int **)malloc(sizeof(int *)* i);//指针数组
	res1.pp = pint;
	for (int *p = find(pdata->p, num, pdata->length - 1),j=0; p != NULL;j++, p = find(p + 1, num, (pdata->length - 1) - (p - pdata->p)))
	{
		pint[j] = p;//循环赋值
		//printf("\n%p,%d\n", pint[j], *pint[j]);
	}
	return res1;
}

数组库的测试

#include<stdio.h>
#include<stdlib.h>
#include"动态数组.h"
void main()
{

	int a[10] = { 231, 112, 1233, 14123, 523, 112, 71, 18, 29, 112 };
	struct data  data1;
	init(&data1);
	addobject(&data1, 10);
	addobject(&data1, 11);
	addobject(&data1, 12);
	//reinit(&data1);
	addobjects(&data1, a, 10);
	printfall(&data1);
	insert(&data1, 1233, 1988, 1);
	insert(&data1, 1233, 1998, 0);
	printfall(&data1);
	system("pause");
}

void main2()
{
	int a[10] = { 231, 112, 1233, 14123, 523, 112, 71, 18, 29, 112 };
	struct data  data1;
	init(&data1);
	addobject(&data1, 10);
	addobject(&data1, 11);
	addobject(&data1, 12);
	//reinit(&data1);
	addobjects(&data1, a, 10);
	printfall(&data1);

	struct findres  resn=  findadlldata(&data1, 112);//查找
	for (int i = 0; i < resn.n; i++)
	{
		printf("\nresn %p,%d\n", *(resn.pp+i), **(resn.pp+i));//二级指针遍历指针数组
	}
	free(resn.pp);//释放内存
	printfall(&data1);


	system("pause");
}

void main1()
{
	int a[10] = { 231, 112, 1233, 14123, 523,116, 71, 18, 29, 110 };
	struct data  data1;
	init(&data1);
	addobject(&data1, 10);
	addobject(&data1, 11);
	addobject(&data1, 12);
	//reinit(&data1);
	addobjects(&data1, a, 10);
	printfall(&data1);

	int *pfind = finddata(&data1, 1101);//查找
	if (pfind != NULL)
	{
		printf("%d,%p", *pfind, pfind);//输出查找结果
	}
	else
	{
		printf("没有找到奥");
	}
	

	{
		printf("\n\n");
		sort(&data1, 0);
		printfall(&data1);
		int *pfind = finddata(&data1, 523);//查找
		if (pfind != NULL)
		{
			printf("%d,%p", *pfind, pfind);//输出查找结果
		}
		else
		{
			printf("没有找到奥");
		}
	}

	{
		printf("\n\n");
		sort(&data1, 1);
		printfall(&data1);
		int *pfind = finddata(&data1, 523);//查找
		if (pfind != NULL)
		{
			printf("%d,%p", *pfind, pfind);//输出查找结果
		}
		else
		{
			printf("没有找到奥");
		}
	}

	getchar();
}


|=========== 吴英强CSDN博客专栏==============|

|== C/C++学院 专栏文章的内容(不定期更新)===|

|== linux驱动开发 探索linux底层的奥秘 ==========|

|== Java基础学习篇 掌握java语言的基础知识=====|

|====== 每天进步一点点,健康快乐每一天 ========|



版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
C中取得数组的地址,赋值给数组结构的字段
C中取得数组的地址,赋值给数组结构的字段
29 0
【愚公系列】2021年11月 C#版 数据结构与算法解析(数组)
【愚公系列】2021年11月 C#版 数据结构与算法解析(数组)
30 0
C/C++ 二维数组
使用C语言用到了二维数组 1 #include 2 #include 3 using namespace std; 4 5 void print_arr_fun1(int arr[][3], int row){ 6 for (int i = 0; i < row; ++i...
1024 0
计算机科学-第9周 数组、结构体、指针综合练习 题目及参考解答
《计算机科学》课程主页在:http://blog.csdn.net/sxhelijian/article/details/13705597 发现第9周的题目及参考没有公布,补上。 1、阅读程序阅读下面的程序,写出运行结果,上机时运行程序,记录结果,从而能够理解指针的用法(1) #include&lt;stdio.h&gt; int main(){ char a[]="Hello Wo
1137 0
第9周-任务4-二维数组类
【题目】建立一个二维数组类Douary,使该类中有以下数据成员、成员函数及友员函数,完成矩阵的输入、输出、加、减、相等判断等操作。 给出的代码部分如下: class Douary {public: Douary(int m, int n);//构造函数:用于建立动态数组存放m行n列的二维数组(矩阵)元素,并将该数组元素初始化为0 ~Douary(); //析构函数:用于释放动态
959 0
c/C++内存分配
一、预备知识—程序的内存分配 一个由c/C++编译的程序占用的内存分为以下几个部分1、栈区(stack)— 由编译器自动分配释放 ,存放函数的参数值,局部变量的值等。其操作方式类似于 数据结构中的栈。
798 0
090828 H 小道理
最近想通的一个道理    人就是这样,简单的道理明白,不过就是很难朝那个道理去做。最后的结果就是错误。所以,人很多时候要需要逼自己的。
541 0
+关注
329
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
低代码开发师(初级)实战教程
立即下载
阿里巴巴DevOps 最佳实践手册
立即下载
冬季实战营第三期:MySQL数据库进阶实战
立即下载