【C语言进阶】 数组指针与指针数组详解 与 数组传参和指针传参

数组指针与指针数组详解 与 数组传参和指针传参

  • 一、指针数组
  • 二、数组指针
    • (1). 数组指针的概念
    • (2). 对比数组指针与指针数组
      • ①题目:
      • ②题目:
      • ③题目:
    • (3). 数组指针的简单应用
      • 补充:下标引用操作符
  • 三、数组传参和指针传参
    • (1). 一维数组传参
    • (2). 二维数组传参
    • (2). 一级指针传参
    • (4). 二级指针传参

一、指针数组

指针数组,顾名思义就是用来存放指针的数组。
下面是一些指针数组的简单例子。

int main()//诸如此类就是指针数组
{
	int a = 1, b = 2, c = 3, d = 4;
	int* pa[4] = { &a,&b,&c,&d };//数组元素为整型指针
	char* pch[10] = { 0 };//数组元素为字符指针
    int** Ppa = {0};//数组元素为二级指针
	return 0;
}

指针数组的应用:存放数组首元素地址。
我们知道,数组名为数组的首元素地址,我们可以创建一个数组Parr来存放其他数组名。

int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 6,7,8,9,0 };
	int arr3[] = { 4,5,6,7,8 };
	int* Parr[] = {arr1,arr2,arr3};
	int i = 0, j = 0;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 5; j++)
		{
			printf("%d ", *(Parr[i] + j));
		}
		printf("\n");
	}
	return 0;
}

二、数组指针

(1). 数组指针的概念

数组指针,即数组的指针,指针指向的内容为数组·。

首先我们要明确,一个存放10个整型的数组arr[10],这个数组的数据类型为 int [10]

数组指针的定义方法 *int(p)[10] = &arr; p为数组指针;

(*p)外边的是指针指向对象的类型 int [10];
()内*p代表它是指针;
p是指针变量的名字;

下面我们上代码来展现数组指针:

int main()
{
	int* pa = NULL;       //pa 是整形指针 - 指向整形的指针 - 可以存放整形的地址
	char* pch = NULL;     //pch是字符指针 - 指向字符的指针 - 可以存放字符的地址
	                    //同理:数组指针 - 指向数组的指针 - 存放数组的地址
	                    
	//arr - 首元素地址
	//&arr[0] - 首元素地址
	//&arr - 数组的地址
	
	int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
	
	int* p0 = arr;   //这是取数组首元素地址
	
	int(*p)[10] = &arr;    //数组指针p用int(*p)[10]表示,其中int[10]是数组的类型
	//若上述p的类型为int* p,就无法与整形指针区别;若int *p[10],[]的优先级比*高,先和[]结合,表示存放指针的数组;

	return 0;
}

(2). 对比数组指针与指针数组

①题目:

区分下面p1 p2是什么类型?
int *p1[10]
int(*p2)[10]

int *p1[10] ---- 存放指针的数组 – 指针数组
int(*p2)[10] — 指向数组的指针 – 数组指针 // p2的类型是 int(*)[10]

②题目:

pa为&arr,请写出pa的类型声明

int main()
{
	char* arr[5];
	return 0;
}

答案:char* (*pa)[5] = &arr;
(*pa)代表pa变量为指针;外面的char* [5]是指针指向对象的类型 。

③题目:

区分下面是什么 ?
注:做下面题目的核心思想为 [ ] 优先级比 * 高

  int *p                   //是一个指针,指向整形
  int arr[5]               //是一个5个元素的整形数组
  int *parr1[10]           //是一个数组,有10个元素,元素类型是int*,parr1是指针数组
  int (*parr2)[10]         //是一个指针,指向一个有10个整形元素的数组                                 //parr2的类型为 int(* )[10]
  int (*parr3[10])[5]      //是一个有10个元素的数组,每个元素是个数组指针,指向有5个整形元素的数组 

(3). 数组指针的简单应用

数组指针的简单应用

数组指针int(*p)[10]=&arr; *p的作用相当于arr

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
	int(*pa)[10] = &arr;
	int i = 0;
	
	for (i = 0; i < 10; i++)
	{
	    //用法1,arr[i]变成(*p)[i],相当于arr[i]
		printf("%d", (*pa)[i]);
	}
	
	for (i = 0; i < 10; i++)
	{
		//用法2,pa解引用为*pa,相当于arr,可以当首元素地址使用
		printf("%d", *(*pa + i));
	}
}

数组指针具体应用

我们直接上代码:
(下面代码的原理是:二维数组名 为 第一行的一维数组的地址)

void pri1(int ARR[3][3], int x, int y)//(参数的数组的形式)
{
	int i, j;
	for (i = 0; i < x; i++)
	{
		for (j = 0; j < y; j++)
		{
			printf("%d ", ARR[i][j]);
		}
		printf("\n");
	}
}


//二维数组int arr[3][3]传参,传的是(二维数组首元素)地址 ,是(一维数组)的地址,是int(*p)[3]
void pri2(int(*p)[3], int x, int y)//(参数是指针的形式)
{
	int i, j;
	for (i = 0; i < x; i++)
	{
		for (j = 0; j < y; j++)
		{
			             /因为p[i]是以p为首元素地址访问下标为i的元素 == *(p+i)
			             //所以可以写成下面几种形式
			printf("%d ", *(*(p + i) + j));
			printf("%d ", (*(p + i))[j]);
			printf("%d ", *(p[i] + j));
			printf("%d ", p[i][j]);   //相当于(p[i])[j] == (每行的数组名)[j]
		}
		printf("\n");
	}
}


int main()
{
	int arr[3][3] = { {1,2,3},{4,5,6},{7,8,9} };
	
	pri1(arr, 3, 3);//数组名传参,数组形式接收
	printf("\n");


	//arr -- 二维数组名 -- 首元素地址
	//二维数组的首元素是什么?
	//这里要把二维数组看作一维数组,每一行(每一个{})看作一个元素
	//那么arr[3][3]有三个元素,每一行是一个元素
	//那么{{1,2,3},{4,5,6},{7,8,9}}的首元素就是{1,2,3},是一维数组
	//二维数组数组名是首元素地址,就是第一行的地址,是一个一维数组的地址
	pri2(arr, 3, 3);
    printf("\n");

	return 0;
}

补充:下标引用操作符

下标引用操作符[]的本质 *(p + i)

p为指针,p[i]表示 – 以p为起始地址,访问下标为i的元素
p[i] == *(p + i)

int main()
{
	int arr[5] = { 1,2,3,4,5 };
	int* p = arr;
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", arr[i]);//数组名+下标引用操作符
		printf("%d ", *(arr + i));//数组首元素地址+下标,解引用
		printf("%d ", *(p + i));//和上一个一样
		printf("%d ", p[i]);//以p为起始地址,访问下标为i的元素
		 
		                  //由上面得出,p[i] == *(p + i)
		printf("\n");
	}
	return 0;
}

三、数组传参和指针传参

(1). 一维数组传参

传参时,可以在形参部分写【数组】或【指针】

void test1(int arr1[])//拿数组接收,可不写大小
{ }
void test2(int arr1[10])//拿数组接收
{ }
void test3(int *arr1)//拿指针接受
{ }
void Test1(int *arr2[20])//拿数组接收
{ }
void Test2(int **arr2)//拿指针接收
{ }
int main()
{
	int arr1[10] = { 0 };
	int* arr2[20] = { 0 };
	test1(arr1); test2(arr1); test3(arr1);
	Test1(arr2); Test2(arr2);
	return 0;
}

(2). 二维数组传参

void test1(int arr[3][5])//用数组来接收
{ }
void test2(int arr[][5])//二维数组行可以省略,列不可以省略
{ }
void test3(int(*arr)[5])//用二维数组的首元素地址(第一行一维数组的地址)来接收
{ }

int main()
{
	int arr[3][5] = { 0 };
	test1(arr);
	test2(arr);
	test3(arr);
	return 0;
}

(2). 一级指针传参

void test(int *p)//用指针接收
{ }
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
	int x = 10;
	int* pa = arr;
	int* px = &x;
	test(pa);      //可传 指针变量
	test(arr);     //可传数组首元素地址
	test(px);      //可传指针变量
	test(&x);      //可传变量地址
	return 0;
}

(4). 二级指针传参

void test(int** p)//用二级指针接收
{ }
int main()
{
	int* arr[10];
	int** pa = arr;
	int n = 10;
	int* p = &n;
	int** Pp = &p;
	test(Pp);      //可传二级指针变量
	test(&p);      //可传一级指针的地址
	test(arr);     //可传指针数组首元素地址
	test(pa);      //可传二级指针变量
	return 0;
}

你可能感兴趣的:(c语言,算法,开发语言)