C语言——指针完全版

一、指针的运算

1.1指针 +- 整数

1.2指针 - 指针

1.3void* 指针

二、指针遍历数组

2.1指针遍历数组

1.了解数组名称的含义（&数组名和数组名的区别）。

一、指针的运算

1.1指针 +- 整数

总结：指针的类型决定了指针向前或者向后走一步有多大（距离）。

1.2指针 - 指针


int main()
{
	int arr[10] = { 0 };
	printf("%d\n", &arr[9] - &arr[0]);
	return 0;
}

当我们想用两个指针相减时，从上图我们可以猜测一下，输出的到底是两地址之间的元素个数还是两个地址的差值（byte）呢？

通过运行我们可以知道，指针 - 指针的结果：指针和指针之间的元素个数。

那么任何两个指针都可以相减吗？从上面的答案我们就可以得到：

指针 - 指针的前提：两个指针指向同一块区域，指针类型是相同的。

那么如果用小指针 - 大指针，我们的结果就成了 -9 .

所以我们可以得到更严谨一些的结论：

指针 - 指针的结果：其绝对值为指针与指针之间的元素个数。

1.3void* 指针

void* 类型的指针 - 不能进行解引用操作符，也不能进行 + - 整数的操作

void* 类型的指针是用来存放任意类型数据的地址

void* 无具体类型的指针

可以用 void* 指针接收任何类型指针，如果需要解引用 void* 指针，可以强制类型转换。

二、指针遍历数组

2.1指针遍历数组

1.了解数组名称的含义（&数组名和数组名的区别）。

数组名是数组首元素的地址。有两个例外：
1. sizeof( 数组名 ) ，计算整个数组的大小， sizeof 内部单独放一个数组名，数组名表示整个数组。
2. & 数组名，取出的是数组的地址。 & 数组名，数组名表示整个数组。
除此 1,2 两种情况之外，所有的数组名都表示数组首元素的地址。

我们来看一段代码了解&数组名和数组名的差别。


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 表示的是 数组的地址 ，而不是数组首元素的地址。

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

2.用指针遍历数组

既然可以把数组名当成地址存放到一个指针中，我们使用指针来访问一个就成为可能。


#include 
int main()
{
    int arr[] = {1,2,3,4,5,6,7,8,9,0};
    int *p = arr; //指针存放数组首元素的地址
    int sz = sizeof(arr)/sizeof(arr[0]);//数组元素个数
    for(int i = 0; i < sz; i++)
   {
        printf("&arr[%d] = %p   <====> p+%d = %p\n", i, &arr[i], i, p+i);
   }
    return 0;
}

可以看到，我们可以通过指针遍历数组的每一个元素：

p+i 其实计算的是数组 arr 下标为i的地址。

那么 *(p+1) 就可以访问数组 arr 的每一个元素。

三、指针数组、数组指针、函数指针

3.1指针数组

指针数组是存放指针的数组。

3.1.1指针数组的形式

我们先来看一下指针数组的样子（其他类型同理）：

int* arr[5];    //数组名称：arr  数组元素个数：5  数组元素的类型：int*

那么知道指针数组有什么用呢？

3.1.2指针数组的使用案例

我们已经知道数组名在绝大多数情况下表示的是数组首元素的地址，那么我们就可以用指针数组模拟出一个二维数组。


int arr1[] = { 0,1,2,3,4,5 };
int arr2[] = { 1,2,3,4,5,6 };
int arr3[] = { 2,3,4,5,6,7 };
 
int* arr[] = { arr1,arr2,arr3 };

那我们应该怎么去使用这个模拟出来的二维数组呢？

我们直接可以用它的下标进行访问。

区别：

我们模拟出这个数组和真正二维数组的区别其实就是真实的二维数组每个元素的元素地址都是连续的，而模拟出的二维数组它的每个一维数组地址并不是连续的。

3.2数组指针

数组指针是指向数组的指针。


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

我们知道整形、全精度浮点型等等都有一个数据类型，int、double...... 当然在这里，数组指针也有它的数据类型。

3.3函数指针

我们可以先来看一段代码


#include 
void test()
{
 printf("hello!\n");
}
int main()
{
 printf("%p\n", test);//打印test地址
 printf("%p\n", &test);//打印&test地址
 return 0;
}

从运行结果我们可以看出来，函数名和数组名其实具有一样的效果，但是，为了便于观察，以后在我们需要函数地址的时候，我们还是会用 &函数名来实现。

如果我们想用指针存储上面的test函数，我们应该怎么办呢？

void(*pf)() = &test;

pf1先和*结合，说明pf1是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为void。

由上面我们可以得到：


int max(int a, int b)
{
	if (a > b)
		return a;
	else
		return b;
}
int main()
{
	int (*pf2)(int, int) = &max;
	return 0;
}

这样我们就可以清楚的了解到函数指针的形式。

三、函数指针数组

3.1函数指针数组的形式

数组是一个存放相同类型数据的存储空间，那我们已经学习了指针数组，

比如：

int * arr [ 10 ];

// 数组的每个元素是 int*

那要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？

（以上述 int max(int a, int b) 为例，假设函数指针数组存放的都是此类函数）

int( * parr[ 10])( int, int);

parr先和 [ ] 结合，表面parr是个数组。

数组的内容是什么呢？

是 int (*)(int, int) 类型的函数指针。

3.2函数指针数组的用途：转移表

我们以一个简单的计算器为例，来看看使用函数指针数组的便捷。

准备内容：

未使用函数指针数组时，我们需要根据用户输入情况，一个函数一个函数的调用：

使用函数数组后，我们只需要把准备阶段的四个函数全部封装到一个函数指针数组中：

再接下来使用的时候，我们就可以灵活运用：

是不是简化了非常多！

四、数组作为函数体参数

定义函数体时，当参数为数组时，既可以用数组接收，也可以用指针接收，其中用数组接收与数组的元素下标无关。

五、函数中用数组作为返回值

返回数组其实就是返回指针。


char* fun()
{
	char str[100] = "hello world!";
	return str;
}
int main()
{
	char* pf;
	pf = fun();
 
	printf("%s\n", pf);
 
	return 0;
}

5.1返回静态局部数组的地址

上述代码有个明显缺陷：

str 在 fun 函数体内创建，为临时变量，当我们在 main 函数中想用pf接收的时候， str 就已经被销毁了，这时候，我们就可以在 fun 函数内用 static 修饰我们的 str ，来延长它的生命周期。

运行如图：

5.2返回文字常量区的字符串的地址

常量字符串是个常量，一直存在。

5.3返回堆内容的地址

malloc的头文件：

#include

malloc 为 str 动态申请内存，大小为100，单位是字节。动态申请的内存在函数结束后也不会被释放。

堆区内容一直存在，直到 free 才释放。

5.4总结

返回的地址，地址指向的内存的内容得存在，才有意义。

六、指针和数组笔试题

6.1一维数组

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

printf ( "%d\n" , sizeof ( a [ 1 ])); //4 代表a[1]这个元素的大小

printf ( "%d\n" , sizeof ( & a )); //4/8 &数组名表示整个数组的地址，是地址大小就是4/8

//字符数组

char arr [] = { 'a' , 'b' , 'c' , 'd' , 'e' , 'f' };

printf ( "%d\n" , sizeof ( arr [ 1 ])); //1 代表arr[1]这个元素的大小

printf ( "%d\n" , strlen ( * arr )); //error 编译器会报错，因为strlen用指针接收，应该传入数组

如果 arr 为数组名（下列数据均放在 sizeof() 中）

arr[0] <-----> arr[1] <-----> 数组类型的大小

arr[0] + 1 == arr[1] <-----> 数组类型的大小

arr + x == &arr[x] <-----> 指针的大小

6.2指针存放字符串

char * p = "abcdef" ;

printf ( "%d\n" , sizeof ( * p )); //1 p表示字符 'a' 的地址，*p为传入a

printf ( "%d\n" , strlen ( p [ 0 ])); //error p[0]表示字符 'a' ,并不是地址

printf ( "%d\n" , strlen ( & p [ 0 ] + 1 )); //5 相当于 &p[1] , strlen 计算 "bcdef\0" 的大小

如果 p 为指针（下列数据均放在 sizeof() 中）

&p[0] == p != &p

*p == p[0]

6.3二维数组

int a [ 3 ][ 4 ] = { 0 };

printf ( "%d\n" , sizeof ( a [ 0 ])); //16 数组名单独放在 sizeof 内部表示整个一维数组

printf ( "%d\n" , sizeof ( * ( a [ 0 ] + 1 ))); //4 数组名表示首元素a[0][0]地址,+1代表a[0][1]

printf ( "%d\n" , sizeof ( a [ 3 ])); //16 sizeof并不会访问数组，a[3]相当于a[1]

七、指针笔试题

笔试题原题：


//笔试题1
struct Test
{
	int Num;
	char* pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}*p;
//假设p 的值为0x100000。 如下表表达式的值分别为多少？
//已知，结构体Test类型的变量大小是20个字节
int main()
{
	p = (struct Test*)0x10000000;
	printf("%p\n", p + 0x1);
	printf("%p\n", (unsigned long)p + 0x1);
	printf("%p\n", (unsigned int*)p + 0x1);
	return 0;
}
 
//笔试题2
int main()
{
	int a[4] = { 1, 2, 3, 4 };
	int* ptr1 = (int*)(&a + 1);
	int* ptr2 = (int*)((int)a + 1);
	printf("%x\n%x", ptr1[-1], *ptr2);
	return 0;
}
 
//笔试题3
int main()
{
	int a[3][2] = { (0, 1), (2, 3), (4, 5) };
	int* p;
	p = a[0];
	printf("%d", p[0]);
	return 0;
}
 
//笔试题4
int main()
{
	int a[5][5];
	int(*p)[4];
	p = a;
	printf("%p\n%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
	return 0;
}
 
//笔试题5
int main()
{
	int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int* ptr1 = (int*)(&aa + 1);
	int* ptr2 = (int*)(*(aa + 1));
	printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));
	return 0;
}
 
//笔试题6
int main()
{
	char* a[] = { "work","at","alibaba" };
	char** pa = a;
	pa++;
	printf("%s\n", *pa);
	return 0;
}
 
//笔试题7
int main()
{
	char* c[] = { "ENTER","NEW","POINT","FIRST" };
	char** cp[] = { c + 3,c + 2,c + 1,c };
	char*** cpp = cp;
	printf("%s\n", **++cpp);
	printf("%s\n", *-- * ++cpp + 3);
	printf("%s\n", *cpp[-2] + 3);
	printf("%s\n", cpp[-1][-1] + 1);
	return 0;
}

7.1笔试题1

p + 0x1 ：已知 p 为 (struct test*) 类型指针，在前面我们也学习到 指针 +- 整数运算，指针变量的类型决定了其 +- 整数的步长，在这里struct test为20字节，故指针运算应加20，十六进制的20为14

(unsigned long)p + 0x1 ：我们知道只有指针类型 +- 整数时，才取决于其类型，故这里直接+1即可

(unsigned int*)p + 0x1：这里 p 的类型变为 unsigned int* ，故 +- 整数的步长为 unsigned int 的大小 4