C进阶_C语言_指针进阶_C语言指针进阶

除了自己的无知，我什么都不懂。

——苏格拉底

*此博客为进阶指针详解，需要有一定的初阶指针基础。

我们知道，指针就是个变量，用来存放地址，地址唯一标识一块内存空间。

指针的大小是固定的4/8个字节。在32位平台上是4个字节，在64位平台上是8个字节。

指针是有类型，指针的类型决定了指针的+-整数的步长，指针解引用操作的时候的权限。

此文章将探讨指针进阶知识。

目录

字符指针

指针数组

数组指针

数组指针的定义

&数组名和数组名

数组指针的使用

数组传参和指针传参

一维数组传参

二维数组传参

一级指针传参

二级指针传参

函数与指针

---

字符指针

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

一般使用：

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

还有一种使用方式如下：
 

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

代码const char* pstr = "hello world."特别容易让同学以为是把字符串hello world.放到字符指针pstr 里了，但是上本质是把字符串hello world.首字符的地址放到了pstr中。

上面代码的意思是把一个常量字符串的首字符h的地址存放到指针变量pstr中。

那就有可这样的面试题：
 

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不同。

我的博客里以前有过类似的题，可以参考下
http://t.csdn.cn/TxXXL

指针数组

我们知道，指针数组是一个存放指针的数组。

这里我们再复习一下，下面指针数组是什么意思？

int* arr1[10]; 
char *arr2[4]; 
char **arr3[5];

它们分别是整形指针的数组、一级字符指针的数组和二级字符指针的数组。

数组指针

数组指针的定义

数组指针是指针？还是数组？

答案是：指针。

我们已经熟悉：

整形指针： int * pint; 能够指向整形数据的指针。

浮点型指针： float * pf; 能够指向浮点型数据的指针。

那数组指针应该是：能够指向数组的指针。

int *p1[10];
int (*p2)[10];

请问，p1和p2分别是什么？

p1是指针数组，这个数组有10个元素用于存放int型指针。

p2是数组指针，它指向的是一个int型的有10个元素的数组。

为什么p2以及前面的*要用括号括起来？

这涉及到优先级。

p2先和*结合，说明p2是一个指针变量，然后指针指向的是一个大小为10个整型的数组。所以p2是一个指针，指向一个数组，叫数组指针。

这里要注意：[]的优先级要高于*号的，所以必须加上()来保证p先和*结合。

&数组名和数组名

arr 和 &arr 分别是什么？

我们知道arr是数组名，数组名表示数组首元素的地址。

那&arr数组名到底是啥？

我们看一段代码：

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

运行结果如下：

可见数组名和&数组名打印的地址是一样的。

难道两个是一样的吗？ 

我们再看一段代码：

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

根据上面的代码我们发现，其实&arr和arr，虽然值是一样的，但是意义应该不一样的。

实际上&arr表示的是数组的地址，而不是数组首元素的地址。（细细体会一下）

本例中 &arr 的类型是：int(*)[10]，是一种数组指针类型。

数组的地址+1，跳过整个数组的大小，所以&arr+1相对于&arr的差值是40。

数组指针的使用

那数组指针是怎么使用的呢？

既然数组指针指向的是数组，那数组指针中存放的应该是数组的地址。

看代码：

#include 
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8,9,0};
int (*p)[10] = &arr;//把数组arr的地址赋值给数组指针变量p
//但是我们一般很少这样写代码
return 0;
}

一个数组指针的使用：

#include 
void print_arr1(int arr[3][5], int row, int col)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
		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++)
	{
		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;
}

学了指针数组和数组指针我们来一起回顾并看看下面代码的意思：

int arr[5];
int *parr1[10];
int (*parr2)[10];
int (*parr3[10])[5];

int arr[5]是整型数组，数组是5个元素。

int *parr1[10]是指针数组，数组10个元素，每个元素是int*类型的。

int (*parr2)[10]是数组指针，该指针指向一个数组，数组是10个元素，每个元素是int类型的。

int (*parr3[10])[5]是数组，有10个元素。数组的每个元素的类型是int(*)[5]的数组指针类型。是存放数组指针的数组。

可能parr3理解起来稍微复杂，请看下图：

左边是parr3，右边是每个存放的数组指针所指向的数组。

数组传参和指针传参

在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢？

一维数组传参

以下传参方式是否可行？

#include 
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);
}

这些传参方式都是可行的。

arr是int型数组。第一个函数虽然没标注数组长度，但是可行的。第二个函数是最标准的传参形式。第三个函数接受的是数组元素的首地址，可行，都是在函数中调用数组元素时就要用*(arr+i)的形式了。

arr2是int型指针数组，数组里存放的是int型指针。第四个函数是最标准的调用形式。第五个函数也可行，它接收的是数组首元素的地址所指向的指针。

二维数组传参

再来看以下传参方式是否可行？

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

第一个函数最标准，可行。

第二个函数没有明确数组的列，不可行。

第三个函数没有明确数组的行，但是明确了数组的列，可行。

前三个和二维数组的初始化类似，可参考我之前的博客：

http://t.csdn.cn/eWCT9

众所周知，一维数组中数组名是首元素地址，在二维数组里，首元素就是第一行的地址。那么第四个函数就不可行了，arr是二维数组又不是一维数组，函数里接收的是一维数组的指针。

第五个函数里是指针数组而又不是二维指针数组，能存指针但又不是指针。但是在传递数组时要么写成相对应维度的数组，要么写成相对应维度的指针。

再看第六个函数，函数里是有五个元素的数组的指针，而arr又是每行五个元素，可以接收arr第一行的地址。可行。

第七个函数里是二级指针，但是arr是二维数组。不可行。二级指针用于接收一级指针的地址。

如果只论能否传参，那么上面这些函数有些不可行的也可以传参，参数能传递，但是用的时候就乱了！关键是看类型是否匹配。

一级指针传参

#include 
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;
}

分析：

arr是首元素地址，被存放在指针变量p中，在调用函数print时，首元素地址以p传入函数内部。由于·数组元素是连续排列的，所以在函数内部打印时，用i控制所指向的数组内的元素即可。

print给的形参是指针，p也是指针，类型匹配就可以完好传递。

当一个函数的参数部分为一级指针的时候，函数能接收什么参数？

可以传指针、地址，也可以传数组。

二级指针传参

#include 
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;
}

函数test中，ptr是二级指针，那么传参时就要用二级指针。

p中存放的是n的地址，pp中存放的是p的地址，pp是二级指针。

在调用函数时，分别传递了pp和&p。pp是二级指针，&p是取地址的地址，也有二级指针的效果。

当函数的参数为二级指针的时候，可以接收什么参数？

可以传递二级指针变量，也可以传递一级指针的地址。如果有一个指针数组arr，arr中每个元素类型为int*，那么在调用函数时可以传递arr。

函数与指针

欲知函数与指针的相关知识，且听下回分解。

最后希望每个人都懂得达克效应：

再次引用开头的话：

除了自己的无知，我什么都不懂。

——苏格拉底