1. 字符指针
在指针的类型中我们知道有一种指针类型为字符指针 char* 。
一般是这样使用:
int main() { char ch = 'w'; //ch = 'a'; char* pc = &ch;//pc就是字符指针 *pc = 'a'; return 0; }
还有一种使用方式如下：
#include <stdio.h> int main() { char arr[] = "abcdef"; //[a b c d e f \0] const char* p = "abcdef";//常量字符串 printf("%s\n", p);//abcdef printf("%c\n", *p);//a return 0; }
代码 const char* p = “abcdef”; 并不是把字符串 abcdef 放到字符指针 p 里去，而是把字符串 abcdef 首字符的地址放到 p 中去；同时，因为 abcdef 是一个常量字符串，所以要用 const 进行修饰，以保证 p 中的内容不会被修改。
注：
不能被改变的常量的数据是放在代码区的，比如代码、常量字符串等等。
有这样一道面试题：
#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; }
首先，我们要知道数组名就是数组首元素的地址，因为 str1 和 str2 是两个不同的数组，所以 str1 和 str2 不相等；而常量字符串是不允许修改的，所以在内存中只需要存一份就可以了，又因为 str3 和 str4 中存的是字符串首字符的地址，所以 str3 和 str4 相等。
2. 指针数组
//指针数组 //整型数组 - 存放整型的数组 //字符数组 - 存放字符的数组 //指针数组 - 存放指针的数组 int main() { int* arr[10];//存放整型指针的数组 return 0; }
使用指针数组模拟实现二维数组：
#include <stdio.h> int main() { int arr1[] = { 1, 2, 3, 4, 5 };//arr1 - int* int arr2[] = { 2, 3, 4, 5, 6 }; int arr3[] = { 3, 4, 5, 6, 7 }; //指针数组 int* arr[3] = { arr1, arr2, arr3 }; int i = 0; for (i = 0; i < 3; i++) { int j = 0; for (j = 0; j < 5; j++) { printf("%d ", arr[i][j]); } printf("\n"); } return 0; }
3. 数组指针
3.1 数组指针的定义
通过类比：
整型指针：能够指向整型数据的指针
浮点型指针：能够指向浮点型数据的指针
我们可以得知：
数组指针应该是：能够指向数组的指针
3.2 &数组名VS数组名
//数组名的理解 //数组名是数组首元素的地址 //有2个例外： //1. sizeof(数组名)，这里的数组名不是数组首元素的地址，数组名表示整个数组，sizeof(数组名)计算的是整个数组的大小，单位是字节 //2. &数组名，这里的数组名表示整个数组，&数组名取出的是整个数组的地址 //除此之外，所有的地方的数组名都是数组首元素的地址 #include <stdio.h> int main() { int arr[10] = { 0 }; printf("%p\n", arr); printf("%p\n", &arr[0]); return 0; }
#include <stdio.h> int main() { int arr[10] = { 0 }; printf("%p\n", arr); printf("%d\n", sizeof(arr)); return 0; }
#include <stdio.h> int main() { int arr[10] = { 0 }; printf("%p\n", arr);//int* printf("%p\n", arr + 1); printf("%p\n", &arr[0]);//int* printf("%p\n", &arr[0] + 1); printf("%p\n", &arr);//int(*)[10] printf("%p\n", &arr + 1); return 0; }
//对于数组名来说 //&数组名得到的是数组的地址 int main() { int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; int (*p)[10] = &arr;//数组的地址，存储到数组指针变量 //解释：p先和*结合，说明p是一个指针变量，然后指针指向的是一个大小为10个整型的数组，所以p是一个指针，指向一个数组，叫数组指针。 //这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。 return 0; }
3.3 数组指针的使用
打印数组中的每个元素：
#include <stdio.h> int main() { int arr[10] = { 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; }
也可以通过数组指针来实现：
#include <stdio.h> int main() { int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; int (*p)[10] = &arr;//*&arr --> arr int i = 0; for (i = 0; i < 10; i++) { //printf("%d ", *((*p) + i)); printf("%d ", (*p)[i]); } return 0; }
但是在这种情况下使用数组指针并不方便，那么数组指针怎么使用呢？
一般在二维数组上才方便
//1 2 3 4 5 //2 3 4 5 6 //3 4 5 6 7 //二维数组传参，形参是二维数组的形式 #include <stdio.h> void Print(int arr[3][5], int r, int c) { int i = 0; for (i = 0; i < r; 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, 2, 3, 4, 5, 6, 3, 4, 5, 6, 7 }; Print(arr, 3, 5); return 0; }
//二维数组传参，形参是指针的形式 #include <stdio.h> void Print(int (*p)[5], int r, int c) { 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, 2, 3, 4, 5, 6, 3, 4, 5, 6, 7 }; Print(arr, 3, 5);//arr是数组名，数组名表示数组首元素的地址；二维数组其实是一维数组的数组，所以数组名是第一个一维数组的地址 return 0; }
学了指针数组和数组指针，我们来看看下面这行代码的意思：
int (*parr3[10])[5];
首先， parr3 和 [ ] 结合，说明 parr3 是一个数组，而数组中的每个元素是数组指针类型，每个元素指向一个有五个元素的整型数组；也就是说 parr3 这个数组里可以存10个 int (*)[5] 类型的数组指针。
4. 数组参数、指针参数
4.1 一维数组传参
#include <stdio.h> 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); return 0; }
4.2 二维数组传参
void test(int arr[3][5])//ok { } void test(int arr[][])//err 形参部分，行可以省略，但是列不能省略。 { } void test(int arr[][5])//ok { } //总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。 //因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。 //这样才方便运算。 void test(int* arr)//err { } void test(int* arr[5])//err 这里的形参是指针数组 { } void test(int (*arr)[5])//ok { } void test(int** arr)//err { } int main() { int arr[3][5] = {0}; test(arr); return 0; }
总结：
//一维数组传参，形参的部分可以是数组，也可以是指针 void test1(int arr[5], int sz) { } void test2(int* p, int sz) { } int main() { int arr[5] = { 0 }; test1(arr, 5); test2(arr, 5); return 0; }
//二维数组传参，形参的部分可以是数组，也可以是指针 void test3(char arr[3][5], int r, int c) { } void test4(char(*p)[5], int r, int c) { } int main() { char arr[3][5] = { 0 }; test3(arr, 3, 5); test4(arr, 3, 5); return 0; }
4.3 一级指针传参
#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]); print(p, sz); return 0; }
思考：
当一个函数的参数部分为一级指针的时候，函数能接收什么参数？
void test(char* p) { } int main() { char ch = '2'; char* ptr = &ch; char arr[] = "abcdef"; test(&ch); test(ptr); test(arr); return 0; }
4.4 二级指针传参
#include <stdio.h> 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(char** p) { } int main() { char n = 'a'; char* p = &n; char** pp = &p; char* arr[5]; test(&p); test(pp); test(arr); return 0; }
5. 函数指针
//函数指针 - 指向函数的指针 //数组指针 - 指向数组的指针 #include <stdio.h> int Add(int x, int y) { return x + y; } int main() { //int arr[10] = { 0 }; //int (*pa)[10] = &arr; printf("%p\n", &Add); printf("%p\n", Add); //函数名是函数的地址 //&函数名也是函数的地址 int (*pf)(int, int) = &Add;//pf是函数指针变量 //int (*)(int, int) 是函数指针类型 return 0; }
再举一个例子：
void test(char* pc, int arr[10]) { } int main() { void (*pf)(char*, int[10]) = &test; void (*pf)(char*, int[10]) = test; void (*pf)(char*, int[]) = &test; void (*pf)(char*, int*) = &test; return 0; }
那么，函数指针如何使用呢？
#include <stdio.h> int Add(int x, int y) { return x + y; } int main() { //int (*pf)(int, int) = &Add; int (*pf)(int, int) = Add; int r = Add(3, 5); printf("%d\n", r); //int m = (*pf)(4, 5); int m = pf(4, 5); printf("%d\n", m); return 0; }
以下是两段有趣的代码：
//0 - int //0 - int* //0x0012ff40 - int //0x0012ff40 - int* //void (*p)() - p是函数指针 //void (*)()是函数指针类型 int main() { //调用0地址处的函数 //1. 将0强制类型转换为void (*)() 类型的函数指针 //2. 调用0地址处的这个函数 (*(void (*)())0)(); return 0; }
int main() { //signal 是一个函数声明 //signal 函数有2个参数，第一个参数的类型是int，第二个参数的类型是 void(*)(int) 函数指针类型 //该函数指针指向的函数有一个int类型的参数，返回类型是void //signal 函数的返回类型也是void(*)(int) 函数指针类型，该函数指针指向的函数有一个int类型的参数，返回类型是void void (*signal(int, void(*)(int)))(int); return 0; }
第二段代码看上去非常复杂，应该如何简化呢？
我们先来看一下typedef的用法：
typedef unsigned int uint; typedef int* ptr_t; typedef int (*parr_t)[10]; typedef int (*pf_t)(int, int); int main() { uint u1; ptr_t p1; int* p2; return 0; }
因此，我们可以这样进行简化：
int main() { typedef void (*pf_t)(int); pf_t signal(int, pf_t); void (*signal(int, void(*)(int)))(int); return 0; }
