数据储存——字符指针和指针数组

已于 2023-04-28 17:50:08 修改
阅读量226 收藏 2
点赞数
文章标签： c++ c语言 算法
于 2023-04-20 00:06:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_75195919/article/details/130243106
版权

字符指针： 

int main()
{
	/*char ch = 'w';
	char* pc = &ch;
	*pc = 'b';
	printf("%c\n", ch);*/

	char* p = "abcdef";//把字符串首字符a的地址，赋值给了p
	//cahr arr[]="abcdef";
	printf("%s\n", p);//%s提供地址，往后打印，知道'\0'
	return 0;
}
*p-(首地址）>0x0012ff40a b c d e f '\0'
int main()
{
	const char* p1 ="abcdef";//常量字符串
	const char* p2 = "abcdef";//p1和p2指向同一个空间
	char arr1[] = "abcdef";//独立数组，创建空间放”abcdef\0“,
	//数组名是首地址，arr1和arr2创造的空间首地址不相等。
	char arr2[] = "abcdef";//独立数组，创建空间放”abcdef\0“

	if (p1 == p2)
		printf("pq--p2\n");//打印
	else
		printf("p1!=p2\n");
	if (arr1 == arr2)
		printf("arr1==arr2\n");
	else
		printf("arr1!=arr2\n");//打印
	return 0;
}

指针数组：

是数组，是用来存放指针的数组

  • int arr[10]——整形数组
    int        int         int         int         int         int         int         int         int         int
    • int ch[5]——字符数组
      char        char        char        char        char
      • 指针数组：int* arr[6];——存放整形指针的数组
        int*        int*        int*        int*        int*        int*
        • char* arr3[5]——存放字符指针的数组
          char*        char*        char*        char*        char*        char*
int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 3,4,5,6,7 };

	int* parr[] = { arr1,arr2,arr3 };

	return 0;
}

 *parr[]

arr1——>1,2,3,4,5        arr1
arr2——>2,3,4,5,6        arr2
arr3——>3,4,5,6,7        arr3

伪二维数组：二维数组在空间上是连续存在的

int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 3,4,5,6,7 };

	int* parr[] = { arr1,arr2,arr3 };

	//0 1 2
	int i = 0;
	//不一定连续存放
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			//*(p+i)-->p[i]
			printf("%d", *(parr[i] + j));
			//printf("%d", *(parr[i] + j));
		}
		printf("\n");
	}

	return 0;
}

数组指针:

               ————指针——指向数组的指针

  • 整形指针——指向整形的指针（int*）
    • 字符指针——指向字符的指针（char*）

数组指针；int （*p2)[10]，p2可以直向一个数组，该数组有10个元素，每一个元素是int类型 

 再次讨论数组名


int main()
{
	int arr[10] = { 0 };
	printf("%p\n", arr);
	printf("%p\n", arr+1);

	printf("%p\n", &arr[0]);
	printf("%p\n", &arr[0]+1);

	printf("%p\n", &arr);
	printf("%p\n", &arr+1);

	//int sz = sizeof(arr);
	//printf("%d\n", sz);
	return 0;
}
//数组名通常表示的都是首元素：
//但是有两个例外
//1.sizeof(数组名）。这里的数组名表示整个数组，计算的大小
//2.数组名，这里的数组名表示的依然是整个数组，
//所以&数组名取出的是整个数组的地址。（单位是字节）
int main()
{
	int arr[10] = { 0 };
	int* p = arr;
	int (*p2)[10] = &arr;
	//数组指针——存放数组的地址
	return 0;
}

进阶：数组指针的使用

错误示例：

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int (*p)[] = &arr;
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < sz; i++)
	{
		printf("%d ",*(*p+i));//p是指向数组的，*p其实就是相当于数组名，
		//数组名又是数组首元素的地址，所以*p本质是数组首元素的地址
	}
	return 0;
}

正确示范：

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

二维数组的首元素是第一行

void print1(int arr[3][5], int c, int r)
{
	int i = 0;
	for (i = 0; i < c; i++)
	{
		int j = 0;
		for (j = 0; j < c; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}
int main()
{
	int arr[3][5] = { 1,2,3,4,5,6,7,8,2,1,4,5,6.7 };
	print1(arr, 3, 5);
	return 0;
}

VS（比较）

void print2(int (*p)[5], int c, int r)
{
    //int (*p)[5];p的类型是：int(*)[5];
	//p是指向一个整型数组的，数组5个元素int[5]
	//p+1-->跳过一个5个int元素的数组
	int i = 0;
	for (i = 0; i < r; i++)
	{
		int j = 0;
		for (j = 0; j < c; j++)
		{
			printf("%d ", *(*(p + i)+j));
		}
		printf("\n");
	}
}
int main()
{
	int arr[3][5] = { 1,2,3,4,5,6,7,8,2,1,4,5,6.7 };
	//arr表示第一行的地址
	//第一行的地址，是一个一维数组的地址
	print1(arr, 3, 5);
	return 0;

数组参数，指针参数：

  • int arr[5];——arr是整形数组
  • int *parr1[10];——parr1是整形指针数组
  • int (*parr2)[10];——parr2是数组指针

int (*parr3[10])[5];——parr3是存放数组指针的数组

*parr3[10](开辟的10个空间）
（存放arr1的首地址）&arr1(0)——>（指向）arr1[5]={1,2,3,4,5}
&arr2(1)——>arr2[5]={1,2,3,4,5}
&arr3(2)——>arr3[5]={1,2,3,4,5}
.......[10]

一维数组传参：

void test(int arr[])//ok
{}
void test(int arr[10])//ok
{}
void test(int* arr)//ok
{}
重点
void test2(int *arr[20])//ok
{}
void test2(int** arr)//ok?
{}//二级指针存放一级指针
int main()
{
	int arr[10] = { 0 };
	int* arr2[20] = { 0 };
	test(arr);
	test2(arr2);
}

二维数组传参：

void test(int arr[3][5])//ok
{}
void test(int arr[][])//NO——行可以省略，列不可以！！！
{}
void test(int arr[][5])//ok
{}
//总结：二维数组传参，函数形参的设计只能省略第一[]的数字。
//因为对一个二维数组，可以不知到有多少行，但是必须知道一行有多少元素。
//这样才方便运算
void test(int* arr)//NO
{}
void test(int* arr[5])//NO
{}
void test(int (*arr)[5])//ok
{}
void test(int **arr)//NO
{}
int main()
{
	int arr[3][5] = { 0 };
	test(arr);//二维数组的数组名表示首元素的地址，其实是第一行的地址
	//第一行是一个一维数组的！
}

一级指针传参：

void print(int* p, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d\n", *(p + i));
	}
}
int mian()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9 };
	int* p = arr;
	int sz = sizeof(arr) / sizeof(arr[0]);
	//一级指针p，传给函数
	printf(p, sz);
	return 0;
}

如果是函数的参数部分是指针：

void print(int* p[定死]){}

int a=10;        printf(&a);

int *ptr=&a;        printf(ptr);

int arr[10];        printf(arr);

 二级指针：

void test(int** ptr)
{
	printf("num=%d\n", **ptr);
}
int main()
{
	int n = 10;
	int* p = &n;
	int** pp = &p;
	test(pp);
	test(&p);
	return 0;
}

 如果函数的形式参数是二级指针，调用函数的时候可以传什么实参？

void test(int** p){}

int*p1;        test(&p1);

int** p2;        test(p2);

int *arr[10];//指针数组        test(arr);

函数指针：

               ——指向函数的指针就是函数指针

int(*pf)(int,int) = &ADD;

int ADD(int x, int y)
{
	return x + y;
}
int main()
{
	int arr[5] = { 0 };
	//&数组名-取出的数组的地址
	int(*p)[5] = &arr;//数组指针
	//&函数名-取出的就是函数
	//printf("%p\n", &ADD);//是函数的地址
	//printf("%p\n", ADD);
	//对于函数来说，&函数名和函数名都是函数的地址

	//int(*pf)(int,int) = &ADD;
	int (*pf)(int, int) = ADD;

	//int ret=(*pf)(2, 3);//通过函数指针，访问函数
	int ret = ADD(2, 3);
	int ret = pf(2, 3);
	//int ret=ADD(2,3);//5
	return 0;
}

函数指针的用法，案例：

int ADD(int x, int y)
{
	return x+y;
}
void calc(int(*pf)(int, int))
{
	int a = 3;
	int b = 5;
	int ret = pf(a, b);
	printf("%d\n", ret);
}
int main()
{
	calc(ADD);
	return 0;
}

int test(const char* str)
{
	printf("test()\n");
	return 0;
}
int main()
{
	//函数指针-也是一种指针，是指向函数的指针
	//printf("%p\n", test);
	//printf("%p\n", &test);
	int (*pf)(const char*) = test;
	(*pf)("abc");
	//pf 和 test
	test("abc");
	pf("abc");

	return 0;
}

( * ( void ( * ) ( ) ) 0 ) ( ); 

 void (* signal (int, void(*)(int) ) ) (int);

 

为什要用复杂的函数指针？？？？

函数指针数组（转移表）：

                        ————函数指针也是指针，把函数和指针放在数组中，就是函数指针数组。

int  ( * arr [ 4 ] ) ( int , int ) = { Add , Sub , Mul , Div } ;

//arr是函数指针数组

int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}
int main()
{
	int (*pf)(int, int) = Add;
	int (*arr[4])(int, int) = { Add,Sub,Mul,Div };
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		int ret = arr[i](8, 4);
		printf("%d	", ret);
	}
	return 0;
}

 

 指向函数指针数组的指针：

               ——指向函数指针数组的指针是一个指针

                        ​​​​​​​        ——指针指向一个数组，数组的元素都是函数指针；

int  ( * ( * pfarr ) [ 5 ] ) ( int , int ) = & pfarr;

int main()
{
	//函数指针数组
	int (*pfarr[])(int, int) = { 0 ,Add,Sub,Mul,Div };
	//指向【函数指针数组】的指针--int* ppfarr = &pfarr;
	 int (*(*pfarr)[5])(int, int) = &pfarr;	
	return 0;
}

回调函数：

                 ——通过函数指针调用的指针

冒泡排序：

void bubble_sort(int arr[],int sz)
{
	
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		int flag = 1;//假设数组是有序的
		int j = 0;
		for (j = 0; j <sz-1-i ; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
				flag = 0;
			}
		}
		if (flag == 1)
		{
			break;
		}
	}
}
int main()
{
	int arr[] = { 0,1,2,3,6,5,4,7,8,9 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr,sz);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}

	return 0;
}

qsort——使用快速排序的思想实现的一个排序函数

陋星沉
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
指针进阶之字符指针（超详细）
人生得意须尽欢
01-02 1万+
指针进阶之字符指针，讲到懂
C语言（数组和指针存储字符串）
little_startoo的博客
02-14 3861
数组和指针存储字符串
C中字符指针数组的用法（也即字符串数组），配合malloc,char **p；char *p[n]；char (*p)[n]；三个的区别
weixin_42224577的博客
08-31 915
当我们需要输入多个字符串时我们就可以借助指针数组或字符串数组来表示。 话不多说直接上程序： char *point[3]={"0","0","0"};/*定义了一个字符指针数组，在这里只是给数组开辟了空间， 也给数组的首地址开辟了一个空间来存放数组的首地址 而这些空间都是用来存放指针的*/ //printf("%p\n%p\n%p\n",point[0],point[1],point[2]); //printf("%p\n%p\n%p\n",&point[0],&poin
C语言字符数组、指针总结
qq_48017759的博客
10-25 3595
C语言字符数组、指针总结
结构体如何存放char*指针
最新发布
u010905359的博客
08-21 399
运算符来动态分配足够的内存空间，并将字符串复制到分配的内存中。只是一个指针，指向一个字符数组或字符串常量，它并不能直接存储字符串内容。一种常见的方式是通过动态内存分配来存储字符串，可以使用。在C++中，你可以使用。
判断2个字符串是否含有相同的字符
05-13
如果要用一个和字符串a一样长的数组counter来计录a中各起点对应与b最大重合子字符串，这个数组也要和a一样长，空间上也不合适，除非情形很特殊，a短b长，不然不如直接malloc()一个堆空间来储存当前最长“子字符串”...
C语言之结构体就这样被攻克了！（绝对值得收藏的文章）整理版.pdf
04-23
我们之前学过一种叫数组的数据结构，它 可以允许我们把很多同类型的数据集中在一起处理。相对于之 前，这已经是一次极大的进步。但是，新的问题，往往又会出 现，这个时候，我们就得上更高端的装备——结构体。 相比...
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar
06-13
10.7 指针数组和指向指针的指针 161 10.7.1 指针数组的概念 161 10.7.2 指向指针的指针 164 10.7.3 main 函数的参数 166 10.8 有关指针的数据类型和指针运算的小结 167 10.8.1 有关指针的数据类型的小结 167 10.8.2 ...
C语言如何指针数组储存字符串,周立功教你学C语言编程：教你数组是如何保存指针的...
weixin_29022115的博客
05-17 3178
>>>>1.字符串与指针数组如果有以下定义：int data0 = 1, data1 = 2, data2 = 3;int *ptr0 = &data0, *ptr1 = &data1, *ptr2 = &data2;实际上地址也是数据，那么数组也可以保存指针，因此可以在基本数据类型的基础上派生一个构造类型，即将相同类型的指针变量集合在一起有序地排列...
C语言—指针数组
qq_30569341的博客
12-20 404
指针数组的使用方式和数组是一样的；其他数据类型的可能存放的是一个整数或浮点数，指针数组是用来存放一个地址，通过*取值符来获取地址中的值；指针数组在内存中开辟一片连续的内存空间，用来保存指针变量，也就是地址；所以指针的地址，与指针存储的地址是两个不同地址；通过字符指针数组，存放多个字符串，通过指针下标来打印出元素的值；创建一个指针数组，指针数组中的每个元素可以存放一个指针变量；
字符 字符串 字符数组 字符串指针 指针数组（C语言）
计算机毕业论文源码，学生个人网页制作html源码。贴近用户做网络推广和互联网优化。
08-09 3596
　　一、字符指针、字符数组 　　1. 字符指针：字符串指针变量本身是一个变量，用于存放字符串的首地址。而字符串本身是存放在以该首地址为首的一块连续的内存空间中并以‘\0’作为串的结束。 　　char *ps="C Language"; 顺序是：1.分配内存给字符指针；2.分配内存给字符串；3.将字符串...
打印 数组指针 指针
qq_42815643的博客
12-20 523
#include <stdio.h> void main() { int a[5][5]= {{10,20,30,40,50},{11,21,31,41,51},{12,22,32,42,52},{13,23,33,43,53},{14,24,34,44,54}}; int aa[5]= {1,2,3,4,5}; int *pp; int (*p)[4]; int i,j; p=a; pp=aa; printf("第一种输出[数.
再谈指针：大佬给你拨开 C指针 的云雾
李肖遥的专栏
04-21 709
说到指针，估计还是有很多小伙伴都还是云里雾里的，有点“知其然，而不知其所以然”。但是，不得不说，学了指针，C语言才能算是入门了。指针是C语言的「精华」，可以说，对对指针的掌握程度，「直接...
关于指针,存储方式
qq_41413485的博客
01-20 2454
在内存中，每8位在内存中作为一个储存单元，每8位（bit）也叫一字节（byte），作为内存单位 在32位系统中，每一个存储单元用4字节（也就是32位二进制数）给自己编号，也就是说，一个地址用32位二进制数来表示。编址范围是2^32，也就是4G。 在64位系统中，每一个存储单元用8字节（也就是64位二进制数）给自己编号，也就是说，一个地址用64位二进制数来表示。编址范围是2^64，也就是16777216T，但实际上只能存128G。 注意： 1、指针存储的是地址是用4个存储单元（一个整型变.....
关于为何字符型指针数组可以存储字符串相关总结
qq_47529104的博客
01-31 2894
关于为何字符型指针数组可以存储字符串相关总结 当字符型指针数组存储了字符串，其实其字符型指针数组的内部的各个元素，存储的其实是每个字符串的首元素的地址，即其每个字符串的首个字符的地址，而其每个字符串又开辟了另外一个空间取存储其数据内容。等于说，若你使用了字符型指针数据存储了x个字符串，就相当于系统其实开辟了另外x个字符数组用于存储这x个字符串，而这字符型数组，存储的是x个字符型数组的首元素地址，由于字符型数组有着可以利用%s格式声明符达到整体输出的特点，所以即使字符型指针的内部存储的只是每个字符型数组的首
【C语言】指针数组变量的赋值与输出
Zscoon
05-07 2038
#include <stdio.h> main() { int i; char a[]="123"; char b[]="456"; char c[]="789"; char *p[3]; p[0]=a;p[1]=b;p[2]=c; for(i=0;i<3;i++) { printf("%s",p[i]); //输出各个指针数组元素的内容 } putchar('\n'); printf("%s",*p);//输出数组所有内容; putchar('\n').
C语言指针与二维数组
qq_38325803的博客
09-04 4196
二维数组在概念上是二维的，有行和列，但在内存中所有的数组元素都是连续排列的，它们之间没有“缝隙”。以下面的二维数组 a 为例： int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} }; 从概念上理解，a 的分布像一个矩阵： 0 1 2 3 4 5 6 7 8 9 10 11 但在内存中，a 的分布是一...
【C语言】指针数组 指针数组存储字符串列表（需回看，多次观看）| C语言面试：请解释一下C语言中的信号处理机制及相关函数的使用。
追光者♂：记录、分享、总结、提升，现象级专栏《Python从入门到人工智能》作者，无惧黑暗，坚信曙光
03-15 2180
目录引例指针数组指针数组存储字符串列表（可回看） 引例 先看一个简单的数组定义并输出数组元素： // 常规的数组定义并输出 #include <stdio.h> const int max = 5; int main(){ int var[]={11,22,33,44,55}; int i; for(i=0;i<max;i++){ printf("Value of var[%d] = %d\n",i,var[i]); } return 0; } 指针数组 //指针数组
字符指针和字符数组的区别
06-07
字符指针和字符数组在 C++ 中都可以用来存储字符串，但是它们有一些区别。 字符数组是一段连续的内存空间，可以存储一段固定长度的字符串。例如，下面的代码定义了一个长度为 6 的字符数组，可以存储一个长度为 5 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值