对指针的详细认识（二）—— 字符指针+指针数组+数组指针+指针参数

---

字符指针

在指针的类型中我们知道有一种指针类型为字符指针 char* 。

int main()
{
  char ch = 'w';
  char *pc = &ch;
  *pc = 'w';
  return 0;
}

上述代码中，将字符变量ch的地址放在字符指针pc中。
其实字符指针还有另外一种使用方法：

int main()
{
  const char* pstr = "hello csdn.";//这里是把一个字符串放到pstr指针变量里了吗？
  printf("%s\n", pstr);
  return 0;
}

上述代码中，字符指针pstr存放的并不是字符串“hello csdn”，而是字符串首元素的地址，即‘h’的地址。
所以当我们对字符指针pstr解引用并以字符的形式打印时，只能得到字符‘h’，我们知道，打印字符串只需要提供字符串首元素地址即可，既然字符指针pstr存放的是字符串首元素地址，那我们只需要提供pstr（字符首元素）并以字符串形式打印，便可以打印字符串“hello csdn”。

做做下面的题目，加深对字符指针和常量字符串的理解：

#include <stdio.h>
int main()
{
  char str1[] = "hello bit.";
  char str2[] = "hello bit.";
  const char *str3 = "hello bit.";
  const char *str4 = "hello bit.";
  if(str1 ==str2)
printf("str1 and str2 are same\n");
  else
printf("str1 and str2 are not same\n");
  
  if(str3 ==str4)
printf("str3 and str4 are same\n");
  else
printf("str3 and str4 are not same\n");
  
  return 0;
}

题目打印的结果是：

这里str3和str4指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域，当几个指针。指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4不同。

注意：
常量字符串跟普通字符串最大的区别是，常量字符串不能被修改，既然不能被修改，那么在内存中没有必要存放两个一模一样的字符，所以在内存中相同的常量字符串只有一个。

指针数组

指针数组是一个存放指针的数组

int* arr1[10]; //整形指针的数组
char *arr2[4]; //一级字符指针的数组
char **arr3[5];//二级字符指针的数组

数组arr1包含10个元素，每个元素都是int*类型。

数组arr2包含4个元素，每个元素都是char*类型。

数组arr3包含5个元素，每个元素都是char**类型。

数组指针

数组指针的定义

数组指针是指针？还是数组？
答案是：指针。
我们已经熟悉：
整形指针： int * pint; 能够指向整形数据的指针。
浮点型指针： float * pf; 能够指向浮点型数据的指针。
那数组指针应该是：能够指向数组的指针。

#include<stdio.h>
int main()
{
	int arr[10] = { 0 };
	int(*p)[10] = &arr;
	//&arr-数组的地址
	return 0;
}

那么数组指针的类型又是如何写出来的呢？

int (*p)[10];
//解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个
指针，指向一个数组，叫数组指针。
//这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。

1、【】的优先级要高于。

2、一个变量除去变量名，便是他的变量类型。

#include<stdio.h>
int main()
{
	int a = 10;//int
	char ch = 'w';//char
	int* p = NULL;//int*
}

数组也可以这样理解：

#include<stdio.h>
int main()
{
	int arr1[10] = { 0 };//int [10]
	int arr2[3][4] = { 0 };//int [3][4]
	int* arr3[10] = { 0 };//int* [10]

	return 0;
}

数组的变量类型说明了数组的元素个数和每个元素的类型：

3.指针变量除去变量名和，便是指针指向的内容的类型。*

int a = 10;
	int* p = &a;//p指向a的类型-int
	char ch = 'w';
	char* pc = &ch;//pc指向ch的类型-char

&数组名VS数组名

int arr[10] = {0};

arr 和 &arr 分别是啥？
我们知道arr是数组名，数组名表示数组首元素的地址。
那&arr数组名到底是啥？

数组名代表整个数组地址的情况只有两种：
1、&数组名。
2、数组名单独放在sizeof内部，即sizeof（数组名）。

int arr[5] = {1,2,3,4,5};

对于该数组，只有两种情况数组名代表整个数组地址

&arr;
sizeof(arr);

除此之外，所有数组名都是首元素地址。
将其与指针联系起来：

#include<stdio.h>
int main()
{
	int arr[5] = { 1,2,3,4,5 };
	int* p1 = arr;//数组首元素地址
	int(*p2)[5] = &arr;//数组的地址
	printf("%p\n", p1);
	printf("%p\n", p1+1);

	printf("%p\n", p2);
	printf("%p\n", p2+1);
	return 0;
}

因为代码中的arr是首元素地址，所以要用int*的指针接收，而&arr是整个数组的地址，所以要用数组指针接收。

虽然一个是数组首元素地址，一个是数组的地址，但是它们存放的都是数组起始位置的地址，所以arr与&arr以地址形式打印出来的值是一样的。

#include <stdio.h>
int main()
{
  int arr[10] = {0};
  printf("%p\n", arr);
  printf("%p\n", &arr);
  return 0;
}

数组首元素地址跟数组地址区别在于，数组首元素+1只能跳过一个元素指向下一个元素，而数组的地址+1则是跳过整个数组指向数组后面的内存空间。

数组指针的使用

#include <stdio.h>
void print_arr1(int arr[3][5], int row, int col)
{
  int i = 0;
  for(i=0; i<row; i++)
 {
    int j = 0;
    for(j=0; j<col; j++)
   {
      printf("%d ", arr[i][j]);
   }
    printf("\n");
 }
}

void print_arr2(int (*arr)[5], int row, int col)
{
  int i = 0;
  for(i=0; i<row; i++)
 {
    int j = 0;
    for(j=0; j<col; j++)
   {
      printf("%d ", arr[i][j]);
   }
    printf("\n");
 }
}
int main()
{
  int arr[3][5] = {1,2,3,4,5,6,7,8,9,10};
 print_arr1(arr, 3, 5);
  //数组名arr，表示首元素的地址
  //但是二维数组的首元素是二维数组的第一行
  //所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
  //可以数组指针来接收
  print_arr2(arr, 3, 5);
  return 0;
}

在这里我们打印一个三行五列的二维数组，传参是我们传入二维数组的数组名，明确打印的起始位置。传入行数和列数明确打印的数据范围。
通过上面对数组名和&数组名的认识，我们知道传参的二维数组数组名是首元素地址，而二维数组首元素就是第一行的元素，即传入的是一维数组的地址，所以我们用数组指针接收。
打印时，通过表达式*(*(p+i)+j )锁定打印目标。

数组参数、指针参数

一维数组传参

#include <stdio.h>
void test(int arr[10])//数组接收
{}
void test(int *arr)//指针接收
{}
void test2(int *arr[20])//数组接收
{}
void test2(int **arr)//指针接收
{}
int main()
{
int arr[10] = {0};
int *arr2[20] = {0};
test(arr);
test2(arr2);
}

整形数组：
当向函数传入整型数组的数组名时，我们有以下几种参数可供接收：
1、数组传参数组接收，我们传入的是整型数组，那我们就用整形数组接收。
2、传入数组名传的是首元素地址，所以用指针接收，数组元素的类型是整型，我们接收整型元素的地址用int*即可。

整型指针数组
当向函数传入整型数组的数组名时，我们有以下几种参数可供接收：
1、数组传参数组接收，我们传入的是整型指针数组，那我们就用整型指针数组接收。
2、指针接收，数组元素是int类型，接收int类型元素的地址用二级指针int**即可。

二维数组传参

void test(int arr[][5])
{}
void test(int (*arr)[5])
{}
{
int arr[3][5] = {0};
test(arr);
}

当向函数传入二维数组的数组名时，我们有以下几种参数可供接收：
1、二维数组传参二维数组接收。
2、指针接收，二维数组首元素地址是二维数组第一行的地址，即一维数组的地址，用数组指针接收即可。
注意：
二维数组传参，函数形参的设计只能省略行，即第一个【】内的数字。

一级指针传参

#include <stdio.h>
void print(int* p, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d\n", *(p + i));
	}
}

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9 };
	int* p = arr;
	int sz = sizeof(arr) / sizeof(arr[0]);
	//一级指针p，传给函数
	print(p, sz);
	return 0;
}

当我们传入的参数为一级指针时，我们可以用一级指针的形参对其进行接收。
思考：
当一个函数的参数部分为一级指针的时候，函数能接收什么参数？

void test(int* p)
{}
#include<stdio.h>
int main()
{
	int a = 10;
	test(&a);//可以传入变量地址
	int* p = &a;
	test(p);//可以传入一级指针
	int arr[10] = { 0 };
	test(arr);//可以传入一维数组数组名
	return 0;
}

总结：
只要传入的表达式最终类型是一级指针类型就可以传参。

二级指针传参

#include <stdio.h>
void test(int** ptr)//二级指针接收
{}
int main()
{
   int n = 10;
   int*p = &n;
   int **pp = &p;
   test(pp);//二级指针
   return 0;
}

当我们传入的参数为二级指针时，我们可以用二级指针的形参对其进行接收。
思考：
当一个函数的参数部分为二级指针的时候，函数能接收什么参数？

void test(char** p)
{
}
int main()
{
	char c = 'b';
	char* pc = &c;
	char** ppc = &pc;
	char* arr[10];
	test(&pc);//可以传入一级指针的地址
	test(ppc);//可以传入二级指针
	test(arr);//可以传入一级指针数组的数组名
	return 0;
}

总结：
只要传入的表达式最终类型是二级指针类型就可以传参。