C语言基础-指针（下）

已于 2023-05-02 21:00:16 修改
阅读量125 收藏
点赞数
分类专栏： C语言 文章标签： c语言 数据结构
于 2023-04-10 10:47:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52902991/article/details/130040836
版权

1、数组与指针，函数封装

数组名即为地址（指针）

#include <stdio.h>

void initArray(int *parr,int size)//*为标记作用
{
	int i;
	for(i =0;i<size;i++)
	{
		printf("请输入第%d个元素的数据：\n",i+1);
		scanf("%d",parr++);
	}
}

void printArray(int *parr,int size)//*为标记作用
{
	int i;
	for(i =0;i<size;i++)
	{
		printf("%d",*parr++);//*为取值作用
	}
}

int main()
{		
	int arry[5];
	int size = sizeof(arry)/sizeof(arry[0]);
	initArray(arry,size);
	printArray(&arry[0],size);//实际参数：数组的首地址/数组名/首个元素的地址
	return 0;
}

2、数组翻转函数封装

#include <stdio.h>

void initArray(int *parr,int size)//*为标记作用
{
	int i;
	for(i =0;i<size;i++)
	{
		printf("请输入第%d个元素的数据：\n",i+1);
		scanf("%d",parr++);
	}
}

void revangeArry(int *parr,int size)
{
	int i,j;
	int temp;
	for(i = 0;i<size/2;i++)
	{
		j = size-1-i;
		temp = parr[i];			//temp = *(parr+i);      地址偏移，paar为数组首元素的地址
		parr[i] = parr[j];		//*(parr+i) = *(parr+j); 这几行*为取值作用
		parr[j] = temp;			//*(parr+j) = temp;
	}
}

void printArray(int *parr,int size)//*为标记作用
{
	int i;
	for(i =0;i<size;i++)
	{
		printf("%d",*parr++);//*为取值作用
	}
}

int main()
{		
	int arry[5];
	int size = sizeof(arry)/sizeof(arry[0]);
	initArray(arry,size);
	printArray(&arry[0],size);//实际参数：数组的首地址/数组名/首个元素的地址
	revangeArry(&arry[0],size);
	printArray(&arry[0],size);
	return 0;
}

3、二维数组地址（指针）

父子数组

int a[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};

a是二维数组名，父数组的名，父数组的地址————行

子数组的名(地址)：a[0]、a[1]、a[2]————————列

问：a+1偏移了多少？a[0]+1偏移了多少？

答：a+1从1到5，16个字节

        a[0]+1从1到2；4个字节

！！！数组名也是数组首元素地址

        对于二维数组，a[1](子数组的名)=&a[1][0](子数组的第一个元素取地址)

        a[2]=&a[2][0]

首地址：①数组名；②首个元素的地址；

*a = a[0]       *(a+1) = a[1]         //此处*为取值作用

实例：

①

#include <stdio.h>

int main()
{
	int arr[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
	
	printf("arr是父数组地址：%p，偏移1后为：%p\n",arr,arr+1);
	printf("arr[0]是子数组地址：%p，偏移后1为：%p\n",arr[0],arr[0]+1);
	printf("arr[0]是子数组地址：%p，偏移1后为：%p\n",*(arr+0),*(arr+0)+1);//对二维数组的第一个元素取值即为{1，2，3，4}，也就是该元素的地址
}

运行结果：

arr是父数组地址：000000000061FDF0，偏移1后为：000000000061FE00
arr[0]是子数组地址：000000000061FDF0，偏移后1为：000000000061FDF4
arr[0]是子数组地址：000000000061FDF0，偏移1后为：000000000061FDF4

②、遍历数组

#include <stdio.h>

int main()
{
	int arr[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
	int i;
	int j;
	for(i=0;i<3;i++)
	{
		for(j=0;j<4;j++)
		{
			printf("地址：%p；数据：%d\n",&arr[i][j],arr[i][j]);
			printf("地址：%p；数据：%d\n",arr[i]+j,*(arr[i]+j));
			printf("地址：%p；数据：%d\n",*(arr+i)+j,*(*(arr+i)+j));
			printf("=============\n");
		}
		printf("\n");
	}
	
}

运行结果：

地址：000000000061FDE0；数据：1
地址：000000000061FDE0；数据：1
地址：000000000061FDE0；数据：1
=============
地址：000000000061FDE4；数据：2
地址：000000000061FDE4；数据：2
地址：000000000061FDE4；数据：2
=============
地址：000000000061FDE8；数据：3
地址：000000000061FDE8；数据：3
地址：000000000061FDE8；数据：3
=============
地址：000000000061FDEC；数据：4
地址：000000000061FDEC；数据：4
地址：000000000061FDEC；数据：4
=============

地址：000000000061FDF0；数据：5
地址：000000000061FDF0；数据：5
地址：000000000061FDF0；数据：5
=============
地址：000000000061FDF4；数据：6
地址：000000000061FDF4；数据：6
地址：000000000061FDF4；数据：6
=============
地址：000000000061FDF8；数据：7
地址：000000000061FDF8；数据：7
地址：000000000061FDF8；数据：7
=============
地址：000000000061FDFC；数据：8
地址：000000000061FDFC；数据：8
地址：000000000061FDFC；数据：8
=============

地址：000000000061FE00；数据：9
地址：000000000061FE00；数据：9
地址：000000000061FE00；数据：9
=============
地址：000000000061FE04；数据：10
地址：000000000061FE04；数据：10
地址：000000000061FE04；数据：10
=============
地址：000000000061FE08；数据：11
地址：000000000061FE08；数据：11
地址：000000000061FE08；数据：11
=============
地址：000000000061FE0C；数据：12
地址：000000000061FE0C；数据：12
地址：000000000061FE0C；数据：12
=============

总结：

二维数组a的有关指针

表示形式 含义 a 二维数组名，指向一维数组a[0]，即0行首地址 a[0]，*(a+0)，*a 0行0列元素地址 a+1，&a[1] 1行首地址 a[1]，*(a+1) 1行0列元素a[1][0]的地址 a[1]+2，*(a+1)+2，&a[1][2] 1行2列元素a[1][2]的地址 *(a[1]+2),*(*(a+1)+2),a[1][2] 1行2列元素a[1][2]的值

4、数组指针

定义一个指针，指向一个数组

数组指针真正意义上等同于二维数组名

也就是说定义一个指针，就是子数组的地址

格式：

        int arr[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};

        int(*p)[4];

        p = arr;

//数组指针遍历数组
#include <stdio.h>

int main()
{
	int arr[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
	int i;
	int j;
	int (*p)[4];
	p = arr;
	for(i=0;i<3;i++)
	{
		for(j=0;j<4;j++)
		{
			printf("%d\n",*(*(p+i)+j));
			
		}
		
	}
	
}

练习：二维数组，输入行列，取值

//二维数组，输入行列，取值
#include <stdio.h>

int findResult(int (*p)[5],int hang,int lie)
{
	int data;
	data = *(*(p+hang)+lie);
	return data;
    //return p[hang][lie];
}

void tipsInputHangLie(int *pm,int *pn)
{
	printf("请输入行列值：");
	scanf("%d%d",pm,pn);
	puts("输入完成！");
}

int main()
{
	int arr[3][5] = {{1,2,3,4,1},{5,6,7,8,1},{9,10,11,12,1}};
	int ihang,ilie;
	int data;
	
	//1、提示用户输入行列值
	tipsInputHangLie(&ihang,&ilie);
	//2、找出对应的那个数
	data = findResult(arr,ihang,ilie);
	//3、打印出来
	printf("第%d行第%d列的数为%d\n",ihang,ilie,data);
}

5、函数指针

函数地址：如果在程序中定义了一个函数，在编译时，编译系统为函数代码分配了一段存储空间，这段存储空间的起始地址（又称入口地址）称为这个函数的指针。

函数名即为地址。

如何定义一个函数指针变量？                                                                                                             int a —— int *p               char c —— char *p             int getData(int a,int b) —— int(*p)(int a,int b)

使用函数指针                                                                                                                                     

//函数指针
#include <stdio.h>

int inDate(int data)
{
	return ++data;
}

void printWelcome()
{
	puts("欢迎！");
}

int main()
{	
	//定义函数指针
	void(*p1)();
	int(*p2)(int data);
	
	//指向函数
	p1 = printWelcome;
	p2 = inDate;
	
	//调用
	(*p1)();
	printf("p2测试：%d\n",(*p2)(10));
	
	return 0;
}

练习：有两个整数a和b，由用户输入1，2或3。如输入1，程序给出最大者，输入2，给出最小者，输入3，求ab之和。

//有两个整数a和b，由用户输入1，2或3。
//如输入1，程序给出最大者，
//输入2，给出最小者，
//输入3，求ab之和。
#include <stdio.h>

int getMax(int data1,int data2)
{
	return data1>data2?data1:data2;
}

int getMin(int data1,int data2)
{
	return data1>data2?data2:data1;
}

int getSum(int data1,int data2)
{
	return data1+data2;
}

int dataHand(int data1,int data2,int (*pfunc)(int data1,int data2))
{
	int result;
	result = (*pfunc)(data1,data2);
	return result;
}
int main()
{
	int a = 1;
	int b = 2;
	int cmd;
	int result;
	
	//函数指针
	int (*pfunc)(int data1,int data2);
	
	printf("请输入：");
	scanf("%d",&cmd);
	switch(cmd)
	{
		case 1:
		pfunc = getMax;
		break;
		case 2:
		pfunc = getMin;
		break;
		case 3:
		pfunc = getSum;
		break;
		default:
		printf("输入错误！");
	}
	
	result = dataHand(a,b,pfunc);
	printf("result = %d\n",result);
	return 0;
}

6、指针数组

int *p[4];

是一个数组，数组的每一项都是一个指针变量

#include <stdio.h>

int main()
{
	int a = 1;
	int b = 2;
	int c = 3;
	int d = 4;
	
	int *p[4] = {&a,&b,&c,&d};//标识
	for(int i = 0;i<4;i++)
	{
		printf("%d ",*（p[i]）);//p[i]是一个地址，对地址取值
	}
	return 0;
}

函数指针数组

//有两个整数a和b,求最大者、最小者、ab之和。
#include <stdio.h>

int getMax(int data1,int data2)
{
	return data1>data2?data1:data2;
}

int getMin(int data1,int data2)
{
	return data1>data2?data2:data1;
}

int getSum(int data1,int data2)
{
	return data1+data2;
}

int main()
{
	int a = 1;
	int b = 2;
	int result;
	
//函数指针数组
	int (*pfunc[3])(int ,int ) = {getMax,getMin,getSum};
	
	for(int i=0;i<3;i++)
	{
		result = (*pfunc[i])(a,b);
		printf("result = %d\n",result);
	}
	return 0;
}

7、指针函数

 函数的返回值为指针类型即地址

8、二级指针

#include <stdio.h>

int main()
{
	int data = 3;
	printf("data的地址为：%p\n",&data);
	
	int *p1 = &data;
	printf("p1保存data的地址为%p，数据是%d\n",p1,*p1);
	
	int **p2 = &p1;
	printf("p2保存p1的地址为%p，数据是%d\n",p2,**p2);
	
}

9、总结

各种指针的定义

①一个整型数：int a;

②一个指向整型数的指针：int *a;  (指针)

③一个指向指针的指针，它指向的指针指向一个整型数：int **a;   （二级指针）

④一个有10个整型数的数组：int a[10];   （数组 ）

⑤一个有10个指针的数组，每个指针指向一个整型数：int *a[10];（指针数组）

⑥一个指向有10个整型数的数组的指针：int (*a)[10];（数组指针，数组每一项为整型数）

⑦一个指向指针的指针，被指向的指针指向一个有10个整型数的数组：int (**a)[10];

⑧一个指向指针的指针，该数组有10个整型指针：int *(*a)[10]（数组指针，数组每一项为整型指针）

⑨一个指向函数的指针，该函数有一个整型参数并返回一个整型数：int (*a)(int);（函数指针）

⑩一个有10个指针的数组，每个指针指向一个函数，该函数有一个整型参数并返回一个整型数：int (*a[10])(int);  （函数指针数组，是一个数组）

⑪一个函数的指针，指向的函数的类型是有两个整型参数并且返回一个函数只针对函数，返回的函数指针指向有一个整型参数且返回整型数的函数：int(*(*a)(int,int))(int);

单行梦想家
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
封装一个函数，如何实现一个字符串的反转
weixin_59519449的博客
08-04 572
在这里我用的是reversestring的方法实现反转 //封装一个函数，实现一个字符串的反转 var lin ="123456789" //方法一： function reversestring(lin){ return lin.split("").reverse().join("") } console.log(reversestring(lin)) //方法二： function reversestring1(lin){ var newlin=
封装函数 reverse翻转数组、数组排序
爬楼梯的前端小白的博客
06-29 596
reverse翻转数组，和sort数组排序冒泡排序
C语言分割字符串，并存入数组
colin988的博客
01-19 9447
关于C语言中的strtok分割函数的使用，并存入二维数组.
js【函数封装】数组反转
朝阳39的博客
05-12 1398
arr.reverse() 即可实现数组反转，以下为自定义函数实现数组反转的方式： 实现方式 1 function reverse(array) { var newArr = []; for (var i = array.length - 1; i >= 0; i--) { newArr[newArr.length] = array[i]; } return newArr; } 实现方式 2 .
函数封装【闰年，冒泡，翻转数组等....】【案例】
egg_er的博客
11-21 534
函数封装 函数章节学习中，敲了一些有代表性的案例… 巩固一下函数的运用吧… 运行以后的图就不再放这里了，直接复制代码去VS-code里运行一下吧… 一·用户输入年份，判断这一年的2月有多少天： <script> // 用户输入年份，判断这一年的2月有多少天 利用函数的调用 function isRanNian(year) { var flag = false; if (year % 4 == 0 &&am
C语言基础 --指针运算（归纳）1.pdf
07-09
字符串注意点：1.只要说明了是字符串，说明该字符串末尾一定有一个结束字符'\0' 2.利用strlen 计算长度时，不算上 结束字符的长度。所以实际长度：实际字符个数+1。 3.定义的时候可以不用写明长度：char string[]=...
C语言基础-初识指针（适合小白）
12-31
指针加上或减去整数会移动到内存中的下一个或上一个位置，根据指针类型和整数值大小，这可能是字节、字或双字的移动。指针之间的关系运算可以用于确定指针间的相对位置。 指针与数组之间的关系密切，数组名实际上是...
c语言知识-指针详解
08-19
指针是一个特殊的变量，它里面存储的数值被解释成为...要搞清一个指针需要搞清指针的四方面的内容：指针的类型，指针所指向的类型，指针的值或者叫指针所指向的内存区，还有指针本身所占据的内存区。让我们分别说明。
课程思政-C语言程序设计-指针基础
03-25
课程思政-C语言程序设计-指针基础
SPT-C语言基础-结构体指针.pdf
09-14
SPT-C语言基础-结构体指针.pdf
JS基础必读——函数
weixin_47638652的博客
03-02 132
视频链接：https://www.bilibili.com/video/BV1ux411d75J?p=114 点击观看视频 函数1 函数的概念2 函数的使用2.1 函数的声明2.2 函数的调用2.3 函数的封装3 函数的参数3.1 形参和实参3.2 函数形参实参个数匹配3.3 函数形和参实参个数不匹配问题3.4 小结4 函数的返回值4.1 return 语句4.2 return 终止函数 1 函数的概念 在JS里面，可能会定义非常多的相同代码或者功能相似的代码，这些代码可能需要大量重复使用。 虽然for循环
816. 数组翻转
duududuud的博客
02-03 560
给定一个长度为 n 的数组 a 和一个整数 size，请你编写一个函数，void reverse(int a[], int size)，实现将数组aa中的前size个数翻转。 输出翻转后的数组 a。 输入格式 第一行包含两个整数 n 和 size。 第二行包含 n 个整数，表示数组 a。 输出格式 共一行，包含 n 个整数，表示翻转后的数组 a。 数据范围 1≤size≤n≤1000, 1≤a[i]≤1000 输入样例： 5 3 1 2 3 4 5 输出样例： 3 2 ...
C语言基础（五）—— 数组、数组地址（步长+1）、字符串输入输出、随机数
此心光明事上练的博客
02-04 3171
在程序设计中，为了方便处理数据把具有相同类型的若干变量按有序形式组织起来——称为数组。数组就是在内存中连续的相同类型的变量空间。同一个数组所有的成员都是相同的数据类型，同时所有的成员在内存中的地址是连续的。数组属于构造数据类型一个数组可以分解为多个数组元素：这些数组元素可以是基本数据类型或构造类型。int a[10];按数组元素类型的不同，数组可分为：数值数组、字符数组、指针数组、结构数组等类别。int a[10];char s[10];
2024年秋招热门笔试算法题（C++)
weixin_44747201的博客
08-26 3404
2023年春招热门算法题（C++)
字符指针、数组指针、指针数组以及指针传参——C语言
weixin_59913110的博客
05-31 1098
1.字符指针 我们先来看两组代码： #include <stdio.h> int main() { char* p1 = "abcdef"; printf("%s", p1); return 0; } #include <stdio.h> int main() { char arr[] = "abcdef"; printf("%s", arr); return 0; } 运行的结果都为。 第二组是我们平时常用的写法，那么第一组为什么会能和第二组打印出相同的
C语言学习笔记之指针
BJTUYBYUAN的博客
03-29 788
9.1指针基本概念入门 内存中字节的编号称为地址，地址就是某块内存所在的位置，指针指向的是就是地址。 #include <stdio.h> int main() { unsigned int a = 100; char str[] = "c.biancheng.net"; printf("%#X, %#x\n", &a, str);//是否输出Ox return 0; } 字符串名本身就代表了字符串的首地址。 C语言的一切都是地址，所以指针用的如何决定了C语言的功底。C语言用
数组指针和指针数组的区别
weixin_34189116的博客
10-22 4660
数组指针（也称行指针）定义 int (*p)[n];()优先级高，首先说明p是一个指针，指向一个整型的一维数组，这个一维数组的长度是n，也可以说是p的步长。也就是说执行p+1时，p要跨过n个整型数据的长度。 如要将二维数组赋给一指针，应这样赋值：int a[3][4];int (*p)[4]; //该语句是定义一个数组指针，指向含4个元素的一维数组。 p=a;        //将该二维数组...
c语言字符串分割存放到数组,用于把一个字符串分割成字符串数组的方法是?()...
weixin_31068491的博客
05-17 1753
函数readDat()是从文件in71.dat中读取20行数据存放到字符串数组xx中(每行字符串长度均小于80)。请函数readDat()是从文件in71.dat中读取20行数据存放到字符串数组xx中(每行字符串长度均小于80)。请编制函数jsSon()，其功能是：以行为单位对字符串按下面给定的条件进行排序，排序后的结果仍按行重新存入字符串数组xx中。最后调用函数 writeDat()把结果xx输...
reverse函数：反转容器内容
热门推荐
Valineliu
11-01 5万+
reverse函数可以反转一个容器中的内容，包含在库中。 1、函数原型 reverse函数等同于下面的代码： template void reverse (BidirectionalIterator first, BidirectionalIterator last) { while ((first!=last)&&(first!=--last)) {
c语言指针基础知识点
最新发布
11-15
以下是C语言指针的基础知识点： 1.指针的定义和初始化 指针是一个变量，其值为另一个变量的地址。定义指针变量时需要指定指针所指向的变量类型，然后使用*运算符来声明指针变量。指针变量的初始化可以为其赋值为另一个变量的地址，也可以将其初始化为NULL。 2.指针的运算 指针可以进行加、减、自增、自减等运算。指针加上一个整数n时，指向的地址会增加n个存储单元的大小，减去一个整数n时，指向的地址会减少n个存储单元的大小。 3.指针的比较 指针可以进行相等、大于、小于等比较运算。当两个指针指向同一个变量时，它们相等；当两个指针指向同一数组中的不同元素时，它们可以进行大小比较。 4.指针的类型转换 指针可以进行类型转换，但需要注意转换后的指针类型必须与指向的变量类型相同，否则可能会导致程序出错。 5.指针和数组 数组名本身就是一个指针，指向数组的第一个元素。可以使用指针来访问数组中的元素，也可以将指针作为函数参数来传递数组。 以下是一个例子，演示了指针的定义、初始化、运算和比较： ```c #include <stdio.h> int main() { int a = 10; int *p = &a; // 定义指向整型变量a的指针p printf("a的值为：%d\n", a); // 输出：a的值为：10 printf("p指向的变量的值为：%d\n", *p); // 输出：p指向的变量的值为：10 printf("p的值为：%p\n", p); // 输出：p的值为：0x7ffeeb5f8a2c printf("p+1的值为：%p\n", p+1); // 输出：p+1的值为：0x7ffeeb5f8a30 printf("p的地址为：%p\n", &p); // 输出：p的地址为：0x7ffeeb5f8a28 printf("p和&a的比较结果为：%d\n", p == &a); // 输出：p和&a的比较结果为：1 return 0; } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值