C语言进阶2:指针的进阶

时间：2024-11-07 12:09:38

本节重点

  1. 字符指针
  2. 数组指针
  3. 指针数组
  4. 数组传参和指针传参
  5. 函数指针（难）
  6. 函数指针数组（难）
  7. 指向函数指针数组的指针
  8. 回调函数（难）

前言

在C语言基础阶段，我们学习过指针相关的一些基础内容，比如说：

  1. 指针是一个变量，用来存放地址，地址是唯一标识一块内存空间
  2. 指针的大小是固定的4 / 8个字节（32位平台 / 64位平台）
  3. 指针是由类型，指针的类型决定了指针的 + -整数的步长，指针解引用操作时候的权限
  4. 指针的运算

1.字符指针

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

一般使用:

int main()
{    
        char ch = 'w';    
        char* pc = &ch;    
        printf("%c\n", *pc);    
        return 0;
}

或

int main()
{
	//这里p指向字符串常量hello world 的首字符地址,字符串常量存储在只读数据段中
    const char* p = "hello world.";     //const char* p 值不可更改,地址可换
    printf("%s\n", p);						//%s --- 打印字符串
    //printf("%s\n", str);为什么不能写成printf("%s\n", *str);       
  	//因为 %s 格式化字符串时，它期望一个 char* 类型的参数，即一个指向字符数组首元素的指针。这个指针指向的是字符串的开始位置。
    return 0;
}

扩展：在C语言中，内存可以被划分为栈区、堆区、静态区、常量区。

##w300##

  • 栈区：局部变量，函数形参，函数调用
  • 堆区：动态内存如malloc等申请使用
  • 静态区：全局变量，static修饰的局部变量
  • 常量区：常量字符串(常量区中的内容在整个程序的执行期间是不允许被修改的，且同一份常量字符串只会创建一份，不会重复创建存储。)

有这样的面试题：

int main()
{
    char str1[] = "hello world";
    char str2[] = "hello world";
    const char* str3 = "hello world";
    const char* str4 = "hello world";
    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;
}
//!!!注 : 在C语言中，使用 == 操作符比较两个数组（或字符串）时，实际上是比较它们(内容)的地址，而不是它们的内容。

打印出的结果：

str1 and str2 are not same
str3 and str4 are same

(自我理解)

  • str1与str2相当于先选两个位置(地址),再搭房子(存hello world),因此两房子不同(只是长得一样,不是同一个房子)
  • 而str3与str4则相当于先造一个房子(存hello world),然后用两张纸写的同一个地址

2.指针数组

//整形数组，存放整形的数组
    int arr1[10];
    //字符数组，存放字符的数组
    char arr2[10];
    
//指针数组,存放指针的数组
    //存放整形指针的数组
    int* arr3[5];
    //存放字符指针的数组
    char* arr4[10];

int main()
{
	const char* a[5] = {"abcdef", "zhangsan", "hehe", "wangcai", "ruhua"};
    //存放指针的数组 - 指针数组，
    //a[5]数组里面存放的是每个字符串首字符的地址
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%s\n", a[i]);		//依次打印
	}

---

    int arr1[5] = { 1,2,3,4,5 };
	int arr2[5] = { 2,3,4,5,6 };
	int arr3[5] = { 3,4,5,6,7 };
 
	int* arr[3] = {arr1, arr2, arr3};
    //arr也是一个指针数组，利用指针数组实现二维数组
    int i = 0;
	int j = 0;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 5; j++)
		{
			printf("%d ", arr[i][j]);	// arr[i][j] 《==》 *(arr[i] + j) 
		}
		printf("\n");
	}
    
    return ;
}

int* arr1[10]; //整型指针的数组

char* ch[5]; //字符指针的数组

char* arr2[4]; // 一级字符指针的数组

char** arr3[5]; //二级字符指针的数组(存放二级指针)

3.数组指针

3.1 数组指针的定义

int main()
{
	int a = 10;
	int* p1 = &a;
	//整型指针 - 指向整型的指针  - 存放整型变量的地址
 
	char ch = 'w';
	char* p2 = &ch;
	//字符指针 - 指向字符的指针  - 存放字符变量的地址
 
	int arr[10] = {1,2,3,4,5};
	int *pa[10] = &arr;//err，因为pa会先和[10]结合
	int (* pa)[10] = &arr;//注: [10]要保持一致
	//取出的是数组的地址存放到pa中，pa是数组指针变量
	//int(* )[10] -> 数组指针类型
	//数组指针 - 指向数组的指针  - 存放的是数组的地址
 
	return 0;
}

首先，我们要知道[]的优先级是比 * 要高的，对于形式1，pa会先与[ ]结合，再与 * 结合，所以形式1是指针数组

（）的优先级又比[]高，所以pa会先于 * 结合，在与[ ]结合，所以形式2是数组指针。

3.2 &数组名VS数组名

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

##w300##

<br>可以看出，arr+1 相较于 arr 跳过了4个字节的大小， <br>而 &arr+1 相较于 &arr 跳过了40（10*4）个字节，一个数组的地址 <br>因为&arr 指向的是一整个数组

大多数情况下数组名是数组首元素的地址，但是有两个例外：

  1. sizeof(数组名)
  2. &数组名

3.3 数组指针的使用

3.3.1 对一维数组的使用

例: 1

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+1));
  	}
  	return 0;
}

例: 2

int main()
{
	int arr[10]={1,2,3,4,5,6,7,8,9,10};
  	int (*p)[10]=&arr;
  	int i=10;
  	for(i=0;i<10;i++)
    {
      	printf("%d",(*p)[i];
    }
  	 return 0;
}

可以看出对一维数组使用例1的方法更方便简捷,例2的方法有点鸡肋

3.3.2 对二维数组的使用

#include<stdio.h>
//常见的方式
void print_arr1(int arr[3][5], int x, int y)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < x; i++)
	{
		for (j = 0; j < y; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}


//数组指针方式
void print_arr2(int(*p)[5], int x, int y)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < x; i++)
	{
		for (j = 0; j < y; j++)
		{
			printf("%d ", (*(p + i))[j]);
            printf("%d ", *(*p + i）+j);
            printf("%d ", *(p[i]+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_arr1(arr,3,5);//数组名，行，列也要传参
    
	print_arr2(arr, 3, 5); //数组名-首元素地址
	return 0;
}

3.3.3 巩固练习

下面这些代码的含义是什么？

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

解析：

int arr[5];
//arr是一个数组，数组有5个元素，每个元素类型是int
//arr类型是  int [5]  --- 去掉变量名，剩下的就是变量的类型

int* parr1[10];
//parr1是一个数组，数组有10个元素，每个元素类型是int*
//parr1是指针数组,类型是 int* [10]

int(*parr2)[10];
//parr2是一个指针，指针指向一个数组，数组有10个元素，每个元素的类型是int
//parr2是数组指针,类型是 int(*)[10]

int(*parr3[10])[5];
//parr3是一个数组，数组有10个元素，每个元素都是一个指 针
//指针指向一个数组，数组有5个元素，每个元素类型是int
//parr3是一个指向数组指针的数组，本质上还是数组
//parr3类型是 int(*[10])[5]

4.数组参数、指针参数

4.1 一维数组传参

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
void test(int arr1[])//ok? 
{}
void test(int arr1[10]) //ok?
{}
void test(int* arr1)//ok?
{}
void test2(int* arr2[20])//ok?
{}
void test2(int** arr2) // ok ?     注:此处传进数组中储存的指针,
												//int* arr2则是存放指针的地址
{}
int main()
{
	int arr1[10] = { 0 };
	int* arr2[20] = { 0 };
	test(arr);
	test2(arr2);
}

答案：以上传参方式相对应的均ok

注意：一维数组传参可以传数组形式，也可以传指针形式，传数组形式的时候数组元素的个数可以不写，也可以写，传指针的时候要注意指针的类型，也就是指针指向什么类型的元素，

比如说指针指向int类型元素，那么指针的类型就是 int*

4.2 二维数组传参

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

总结 : 二维数组传参，函数形参的设计只能省略第一个[ ]的数字。
因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
这样才方便运算。
二维数组传参也能写成指针的形式，指针的类型应该是数组指针。 传什么,就用什么接收

4.3 一级指针传参

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 print(int arr1[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d\n", arr[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 1发生退化，变成了指向数组第一个元素的指针。这意味着在函数内部，arr 1被当作一个指针来处理，而不是一个完整的数组。

4.4 二级指针传参

void test(int** p)
{
}
int main()
{
	int* p1;
	int** ptr;
	int* arr[5];
	test(&p1);//一级指针取地址.*p指向的元素
	test(ptr);//二级指针
	test2(arr);//一级指针数组的首元素(首地址)指向的元素
	return 0;
}

5.函数指针

我们创建函数的时候，就会在内存中开辟一块空间，既然占用了内存空间，那就有对应的内存空间地址。
函数指针，顾名思义就是指向函数的指针。

int add(int x,int y)
{
	return x + y;
}


int main()
{
	printf("%p\n", add);
	printf("%p\n", &add);
  	//注意：& 函数名 和 函数名均表示函数的地址！
	// 数组名 不等于 &数组名 但  函数名 等于 &函数名
	//注意这里，add 和 &add 是一样的，都是取函数的地址 
 
	//1.pf = &add;
	//2.(*pf)() = &add;//说明* pf是个函数,函数指向add
	//3.int (*pf)(int x, int y) = add;//函数的参数是（int x,int y），返回类型是int
	
	int (*pf)(int x, int y) = add;
	int sum = (*pf)(3, 5);			//函数指针的使用
    //pf就是函数指针变量
	printf("%d\n", sum);
 
	//int sum = add(3, 5);
	//int sum = pf(3, 5);像上面函数这样写也是ok的，
    //语法上来说，*可以去掉，我们加上*用来帮助理解(类似&add调用时不写&)
 
	return 0;
}

可以看出,函数指针和数组指针十分类似
int (*p)[10] int (*p)(int ,int)

分下下面两段代码

代码1：

(*(void (*)())0)();
void (*)()——函数指针类型

(void (*)())0 —— 把0强制转化为一个函数的地址

(*(void ( * )())0)();——解引用0地址的函数，并调用

代码2：

void (*signal(int , void(*)(int)))(int);
signal ( int , void ( * )( int ) )——signal是函数名， 第一个参数是int，第二个参数是一个函数指针

剩下void（ * ）（ int ）——说明signal的返回类型也是一个函数指针类型

上述代码是一次函数声明 // 声明的函数叫：signal // signal函数的第一个参数是int类型的 // signal函数的第二个参数是一个函数指针类型，该函数指针指向的函数参数是int，返回类型是void // signal函数的返回类型也是一个函数指针类型，该函数指针指向的函数参数是int，返回类型是void

// void (*)(int) signal(int, void( * )(int)); //err

上述简化是错的，可以用 typedef 函数进行简化

typedef void （*pf_t）（int） ;//pf_t为 void ( * )(int) 函数指针类型

pf_t signal( int, pf_t);

6.函数指针数组

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

int* arr[10];
数组的每个元素是int* 与 int (* pf)(int......)---函数指针

那要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢 ?
int ( * parr1[10] )(int...... ); √
int* parr2[10] ( ); x
int (*)( ) parr3[10]; x

  • parr1先和[结合，说明parr1是数组。
  • 数组的内容是什么呢 ?
  • 是int(*)()类型的函数指针。

例题： 写一个计算器
整数的加、减、乘、除

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}
void menu()
{
	printf("***************************\n");
	printf("***** 1.add    2. sub  ****\n");
	printf("***** 3.mul    4. div  ****\n");
	printf("***** 0.exit           ****\n");

}
int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		
		switch (input)
		{
		case 1:
			printf("请输入2个操作数:>");
			scanf("%d %d", &x, &y);
			ret = Add(x, y);
			printf("%d\n", ret);
			break;
		case 2:	
			printf("请输入2个操作数:>");
			scanf("%d %d", &x, &y);
			ret = Sub(x, y);
			printf("%d\n", ret);
			break;
		case 3:
			printf("请输入2个操作数:>");
			scanf("%d %d", &x, &y);
			ret = Mul(x, y);
			printf("%d\n", ret);
			break;
		case 4:
			printf("请输入2个操作数:>");
			scanf("%d %d", &x, &y);
			ret = Div(x, y);
			printf("%d\n", ret);
			break;
		case 0:
			printf("退出计算器\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);
}

改进

//这里省略各种函数，可参考上述代码
//函数指针数组   - 转移表
int (*pfArr[])(int, int) = { 0, Add, Sub, Mul, Div };

int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
 
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		if (input == 0)
		{
			printf("退出计算器\n");
			break;
		}
		if (input >= 1 && input <= 4)
		{
			printf("请输入2个操作数:>");
			scanf("%d %d", &x, &y);
			ret = pfArr[input](x, y);
			printf("%d\n", ret);
		}
		else
		{
			printf("选择错误\n");
		}	
	} while (input);
}

这种函数指针数组 我们经常称为 转移表

7.指向函数指针数组的指针

函数指针：
int ( *pf ) ( int , int );

函数指针数组：
int ( *pfarr[ 10 ] ) ( int , int );

指向函数指针数组的指针:
int ( *  (*ptr)[10]   ) ( int , int ) = &pfarr;

暂时能认识就行

8.回调函数

8.1 回调函数定义

回调函数就是一个通过函数指针调用的函数。
如果你把函数的指针（地址）作为参数传递给另一个 函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。
回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进 行响应。

switch (input)
		{
		case 1:
			printf("请输入2个操作数:>");//每个case中语句执行重复度太高
			scanf("%d %d", &x, &y);
			ret = Add(x, y);
			printf("%d\n", ret);
			break;
		case 2:	
			printf("请输入2个操作数:>");
			scanf("%d %d", &x, &y);
			ret = Sub(x, y);
			printf("%d\n", ret);
			break;
		case 3:
			printf("请输入2个操作数:>");
			scanf("%d %d", &x, &y);
			ret = Mul(x, y);
			printf("%d\n", ret);
			break;
		case 4:
			printf("请输入2个操作数:>");
			scanf("%d %d", &x, &y);
			ret = Div(x, y);
			printf("%d\n", ret);
			break;
		case 0:
			printf("退出计算器\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}

每个case中语句执行重复度太高
改进

//这里省略各类计算函数，可参考上面的代码
void calc(int (*p)(int, int))
{
	int x = 0;
	int y = 0;
	int ret = 0;
	printf("请输入2个操作数:>");
	scanf("%d %d", &x, &y);
	ret = p(x, y);
	printf("%d\n", ret);
}
int main()
{
	int input = 0;
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);		
		switch (input)
		{
		case 1:
			calc(Add);
			break;
		case 2:	
			calc(Sub);
			break;
		case 3:
			calc(Mul);
			break;
		case 4:
			calc(Div);
			break;
		case 0:
			printf("退出计算器\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);

当calc函数传送的是Add函数的地址，这是p调用的是Add函数，这是我们称Add为回调函数

这里并不是直接调用各种计算函数，而是把计算函数函数的地址，传递给了calc函数
再由calc函数指针 int ( * p)(int, int) 之后，在适当位置通过函数指针 p 调用它所指向的函数

这个机制就称为回调函数

8.2 qsort函数的使用

8.2.1 回顾冒泡排序



void bubble_sort(int arr[],int sz)
{
  	//趟数
  int i=0;
  for(i=0;i<sz-1:i++)
    {
    //一趟排序的过程
    int j=0;
    for(j=0;j<sz-1-i;j++)
      {
          if(arr[j]>arr[j+i])
          {
              int tem=arr[i];
              arr[j]=arr[j+i];
              arr[j+i]=tem;
          }
      }
    }
}

int main(
{
	//对数组进行排序升序
    int arr[]={9,8,7,6,5,4,3,2,1,0};
    int sz=sizeof(arr)/sizeof(arr[0]);
    bubble_sort(arr,sz);
    //0,1,2,3,4,5,6,7,8,9
    //打印
    int i=0;
    for(i=0;i<sz;i++)
      {
        printf("%d",arr[i]);
      }
}
//缺陷 : 只能排整数

8.2.2 qsort介绍

使用
void qsort(void* base,size_t num,size_t size,int (*cmpar)(const void*, const void*));
void qsort(void* base,//待排序目标数组的起始位置
	size_t num,//数组的元素个数
	size_t width,//每个元素占用的字节数
	int(__cdecl * compare)(const void* elem1, const void* elem2)
	//函数指针，排序所使用的比较函数
	//不同类型的数据比较的方法是不一样的，所以需要将比较方法写成函数传递给qsort
   //简化：int(* cmp)(const void* elem1, const void* elem2) 
   //函数指针，指针指向的参数有两个，参数类型都是const void*,函数返回类型是int

int arr[]={9,8,7,6,5,4,3,2,1,0};
qsort(arr , sz , sizeof(arr[0]))

void* 类型讲解： void是无，空的含义，void * 表示的是无类型的指针。 void* 指针可以接收任意类型的地址（void 可以看作指针万能筒，可以接收任意类型） void 类型指针不能进行解引用操作的。

理解：我们知道指针的类型决定了指针解引用操作时访问字节的个数，如果指针类型是void * ，无类型指针，那么就无法得知该指针解引用访问多少个字节数。
void* 类型指针不能进行++ / ±整数运算的操作。

理解：我们知道指针类型的意义除了决定指针解引用时访问字节的个数外，还决定了指针 + -整数运算的步长，如果指针类型是void * 无类型指针，那么就无法得知该指针 + -的步长到底是多少个字节。

8.2.3 qsort在升序降序中的使用

#include<stdio.h>
#include<stdlib.h>
	//为了调用qsort，需要将比较函数传给qsort
	//按照qsort函数参数的类型，写出需要使用的比较函数
	int cmp_int(const void* elem1, const void* elem2)
{

	return *(int*)elem1 - *(int*)elem2;
}
void test1()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	qsort(arr, sz, sizeof(arr[0]), cmp_int);
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
int main()
{
	test1();//排序整型数组并打印
	return 0;
}

8.2.3 qsort在结构体排序中的使用

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct Stu
{
	char name[20];
	int age;
};
int cmp_Stu_by_age(const void* e1, const void* e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
int cmp_Stu_by_name(const void* e1, const void* e2)
{
	//字符串比较需要用到字符串比较库函数strcmp
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
void test3()
{
	struct Stu s[] = { {"zhangsan",20},{"lisi",30},{"wangwu",10} };
	int sz = sizeof(s) / sizeof(s[0]);
	int i = 0;
	qsort(s, sz, sizeof(s[0]), cmp_Stu_by_age);
	printf("按年龄排序：\n");
	for (i = 0; i < sz; i++)
	{
		printf("%s,%d\n", s[i].name, s[i].age);
	}
	qsort(s, sz, sizeof(s[0]), cmp_Stu_by_name);
	printf("按名字排序：\n");
	for (i = 0; i < sz; i++)
	{
		printf("%s,%d\n", s[i].name, s[i].age);
	}
}
int main()
{
	test3();//排序结构体数组并打印
	return 0;
}

8.3 用冒泡函数的思想实现 qsort 函数

改造冒泡排序,使得其能排序任意指定数组

#include<stdio.h>
#include<string.h>
int cmp_int(const void* elem1, const void* elem2)
{
	return (*(int*)elem1 - *(int*)elem2);
}
void Swap(char* e1, char* e2, int width)
{
	int i = 0;
	//逐个字节交换
	for (i = 0; i < width; i++)
	{
		//方法一：
		//char tmp = *(e1 + i);
		//*(e1 + i) = *(e2 + i);
		//*(e2 + i) = tmp;
		//方法二：
		char tmp = *e1;
		*e1 = *e2;
		*e2 = tmp;
		e1++;
		e2++;
	}
}

void Bubble_sort(void* base, int num, int width, int (*cmp)(void* e1, void* e2))
{
	int i = 0;//size_t就是unsigned int无符号整型的类型重定义，这里可以直接用int类型
	//确定排序的趟数
	for (i = 0; i < num - 1; i++)
	{
		int j = 0;
		//确定每趟排序的对数
		for (j = 0; j < num - 1 - i; j++)
		{
			//比较大小
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				//元素位置交换
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
	}
}

//void qsort(void* base,//待排序目标数组的起始位置
//	       size_t num,//数组的元素个数
//	       size_t width,//每个元素占用的字节数
//	       int(__cdecl* compare)(const void* elem1, const void* elem2)//函数指针，
//排序所使用的比较函数
//   //简化：int(* cmp)(const void* elem1, const void* elem2) 
//   //函数指针，指针指向的参数有两个，参数类型都是const void*,函数返回类型是int
//   //不同类型的数据比较的方法是不一样的，所以需要将比较方法写成函数传递给qsort
//           );

void test4()
{
	int arr[] = { 1,3,5,7,9,2,4,6,8,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	Bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}

struct Stu
{
	char name[20];
	int age;
};
int cmp_Stu_by_age(const void* e1, const void* e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
int cmp_Stu_by_name(const void* e1, const void* e2)
{
	//字符串比较需要用到字符串比较库函数strcmp
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}

void test3()
{
	struct Stu s[] = { {"zhangsan",20},{"lisi",30},{"wangwu",10} };
	int sz = sizeof(s) / sizeof(s[0]);
	int i = 0;
	qsort(s, sz, sizeof(s[0]), cmp_Stu_by_age);
	printf("按年龄排序：\n");
	for (i = 0; i < sz; i++)
	{
		printf("%s,%d\n", s[i].name, s[i].age);
	}
	Bubble_sort(s, sz, sizeof(s[0]), cmp_Stu_by_name);
	printf("按名字排序：\n");
	for (i = 0; i < sz; i++)
	{
		printf("%s,%d\n", s[i].name, s[i].age);
	}
}
int main()
{
	test3();//调用模拟排序函数排序struct Stu类型数据并打印
	test4();//调用模拟排序函数排序int类型数据并打印
	return 0;
}

9.指针和数组经典笔试题解析

9.1 arr[],{ 1,2,3,4 },sizeof

请写出下面程序执行的结果

#include<stdio.h>
int main()
{
	//一维数组
	int a[] = { 1,2,3,4 };
	printf("%d\n", (a));
	printf("%d\n", sizeof(a + 0));
	printf("%d\n", sizeof(*a));
	printf("%d\n", sizeof(a + 1));
	printf("%d\n", sizeof(a[1]));
	printf("%d\n", sizeof(&a));
	printf("%d\n", sizeof(*&a));
	printf("%d\n", sizeof(&a + 1));
	printf("%d\n", sizeof(&a[0]));
	printf("%d\n", sizeof(&a[0] + 1));
	return 0;
}

解析：数组名表示首元素地址，但有两个例外：
1.sizeof(数组名)-- - 此时数组名表示整个数组。 2.& 数组名-- - 此时数组名表示整个数组。
注意：上面这两种例外的情况都需要 sizeof / &后面直接跟数组名，如果不是直接 + 数组名，则不是表示整数数组。
除了上面两个例外情况外，余下遇到的所有情况数组名均表示首元素地址

#include<stdio.h>
int main()
{
	//一维数组
	int a[] = { 1,2,3,4 };
	printf("%d\n", sizeof(a));
	// 16 sizeof(数组名)，数组名表示整个数组，大小为4*4=16个字节
	printf("%d\n", sizeof(a + 0));
	//4/8 此时数组名表示首元素地址，a+0首元素地址+0仍表示首元素地址，地址大小为4/8个字节
	printf("%d\n", sizeof(*a));
	// 4  此时数组名表示首元素地址,*a表示首元素，为int类型，大小为4个字节
	printf("%d\n", sizeof(a + 1));
	//4/8 此时数组名表示首元素地址，a+1 首元素地址+1表示第二个元素地址，地址大小为4/8个字节
	printf("%d\n", sizeof(a[1]));
	//4 此时数组名表示首元素地址 a[1]表示第二个元素，为int类型，大小为4个字节
	printf("%d\n", sizeof(&a));
	//4/8 &数组名表示取出数组的地址，地址大小为4/8个字节
	printf("%d\n", sizeof(*&a));
	//16 &a是取出数组地址，*&a是对数组地址解引用，得到是数组，sizeof(数组)计算数组大小--16
	printf("%d\n", sizeof(&a + 1));
	//4/8 &a是取出数组地址,&a+1表示跳过整个数组，指向整个数组后面的地址，地址大小为4/8个字节
	printf("%d\n", sizeof(&a[0]));
	//4/8 &a[0]表示取出第一个元素的地址，地址大小为4/8个字节
	printf("%d\n", sizeof(&a[0] + 1));
	//4/8 &a[0]表示取出第一个元素的地址，&a[0] + 1表示第二个元素的地址，地址大小为4/8个字节
	return 0;
}

9.2 arr[],{'a','b','c'},sizeof

请写出下面程序执行的结果

#include<stdio.h>
int main()
{
	//字符数组
	char arr[] = { 'a ', 'b', 'c', 'd', 'e', 'f' };
	printf("%d \n", sizeof(arr));
	printf("%d\n", sizeof(arr + 0));
	printf("%d\n", sizeof(*arr));
	printf("%d\n", sizeof(arr[1]));
	printf("%d\n", sizeof(&arr));
	printf("%d\n", sizeof(&arr + 1));
	printf("%d \n", sizeof(&arr[0] + 1));
    return 0;
}

详解及结果展示：

#include<stdio.h>
int main()
{
	//字符数组
	char arr[] = { 'a ', 'b', 'c', 'd', 'e', 'f' };
	printf("%d \n", sizeof(arr));
	//6  计算的是数组大小，每个元素是一个字符，6*1=1
	printf("%d\n", sizeof(arr + 0));
	//4/8 arr+0还是表示首元素地址，地址大小是4/8个字节
	printf("%d\n", sizeof(*arr));
	//1 *arr表示首元素，类型是char，char大小是1个字节
	printf("%d\n", sizeof(arr[1]));
	//1 arr[1]表示第二个元素，类型是char，char大小是1个字节
	printf("%d\n", sizeof(&arr));
	//4/8 &arr表示取出数组的地址，地址大小是4/8个字节
	printf("%d\n", sizeof(&arr + 1));
	//4/8 &arr表示取出数组的地址,&arr+1表示跳过整个数组，到数组后面的地址，地址大小是4/8个字节 
	printf("%d \n", sizeof(&arr[0] + 1));
	//4/8 &arr[0]表示取出首元素的地址，&arr[0]+1表示取出第二个元素的地址，地址大小是4/8个字节
    return 0;
}

9.3 arr[],{'a','b','c'},strlen

请写出下面程序执行的结果
strlen函数是求字符串长度，需要找到 ’/0 ’

#include<stdio.h>
#include<string.h>
int main()
{
	//字符数组
	char arr[] = { 'a ', 'b', 'c', 'd', 'e', 'f' };
    printf("%d\n", strlen(arr));
	printf("%d\n", strlen(arr + 0));
	printf("%d\n", strlen(*arr));
	printf("%d\n", strlen(arr[1]));
	printf("%d\n", strlen(&arr));
	printf("%d\n", strlen(&arr + 1));
	printf("%d\n", strlen(&arr[0] + 1));
    return 0;
}

详解及结果展示：

#include<stdio.h>
#include<string.h>
int main()
{
	//字符数组
	char arr[] = { 'a ', 'b', 'c', 'd', 'e', 'f' };
	printf("%d\n", strlen(arr));
	//随机值， arr表示首元素地址，数组中没有\0，所以用strlen计算长度的时候不知道会在哪里停止，所以是随机值
	printf("%d\n", strlen(arr + 0));
	//随机值， arr+0表示首元素地址，数组中没有\0，所以用strlen计算长度的时候不知道会在哪里停止，所以是随机值
	printf("%d\n", str1en(*arr));
	//错误写法 ,strlen后面需要传递一个地址，*arr表示首元素，首元素是字符'a',其ASCII码是97，strlen会将97当作地址来处理
	//此时会造成越界访问，运行时会报错
	printf("%d\n", strlen(arr[1]));
	//错误写法 ,strlen后面需要传递一个地址，arr[1]表示第二个元素，首元素是字符'b',其ASCII码是98，strlen会将97当作地址来处理
	//此时会造成越界访问，运行时会报错
	printf("%d\n", strlen(&arr));
	//随机值, &arr表示数组的地址，数组中没有\0，所以用strlen计算长度的时候不知道会在哪里停止，所以是随机值
	printf("%d\n", strlen(&arr + 1));
	//随机值， &arr+1表示跳过数组后的地址，后面不知道什么时候遇到'\0',所以是随机值
	printf("%d\n", strlen(&arr[0] + 1));
	//随机值， &arr[0] + 1表示第二个元素的地址，后面不知道什么时候遇到'\0',所以是随机值
	return 0;
}

9.4 arr[],"abcdef",sizeof

请写出下面程序执行的结果

#include<stdio.h>
int main()
{
	char arr[] = "abcdef";
	printf("%d\n", sizeof(arr));
	printf("%d\n", sizeof(arr + 0));
	printf("%d\n", sizeof(*arr));
	printf("%d\n", sizeof(arr[1]));
	printf("%d \n", sizeof(&arr));
	printf("%d\n", sizeof(&arr + 1));
	printf("%d\n", sizeof(&arr[0] + 1));

	return 0;
}

sizeof只关注占用内存空间的大小,单位是字节,不关心内存中存放的是什么
sizeof是操作符
strlen是求字符串长度的,统计的是\0出现前出现的字符个数,找到\0结束,所以可能存在越界访问
strlen是库函数
详解及结果展示：

#include<stdio.h>
int main()
{
	char arr[] = "abcdef";
	printf("%d\n", sizeof(arr));
	//7  用字符串来初始化字符串数组时，最后会自动添加字符串结束标志'\0'
	//数组arr中实际存放 abcdef+\0 7个元素 所以sizeof(arr)求数组的长度是 1*7=7个字节
	printf("%d\n", sizeof(arr + 0));
	//4/8   arr + 0表示首元素地址，地址的大小是4/8个字节
	printf("%d\n", sizeof(*arr));
	//1  *arr表示首元素，arr首元素是一个字符char类型'a',大小是1个字节
	printf("%d\n", sizeof(arr[1]));
	//1  arr[1]表示第二个元素，arr首元素是一个字符char类型'a',大小是1个字节
	printf("%d \n", sizeof(&arr));
	//4/8  &arr表示取出数组的地址，地址的大小是4/8个字节
	printf("%d\n", sizeof(&arr + 1));
	//4/8   &arr + 1表示跳过数组的地址，得到数组后面的地址，地址的大小是4/8个字节
	printf("%d\n", sizeof(&arr[0] + 1));
	//4/8   &arr[0]表示首元素地址，&arr[0] + 1表示第二个元素的地址，地址的大小是4/8个字节
	return 0;
}

9.5 arr[],"abcdef",strlen

请写出下面程序执行的结果

#include<stdio.h>
#include<string.h>
int main()
{
	char arr[] = "abcdef";
	printf("%d\n", strlen(arr));
	printf("%d\n", strlen(arr + 0));
	printf("%d\n", strlen(*arr));
	printf("%d\n", strlen(arr[1]));
	printf("%d\n", strlen(&arr));
	printf("%d\n", strlen(&arr + 1));
	printf("%d\n", strlen(&arr[0] + 1));
	return 0;
}

详解及结果展示：

#include<stdio.h>
#include<string.h>
int main()
{
	char arr[] = "abcdef";
	printf("%d\n", strlen(arr));
	//6 数组arr中实际包含"abcdef \0"，strlen在往后找\0的时候，经过6个char刚好找到\0
	//strlen在计算字符串长度的时候，'\0'不计算到长度中
	printf("%d\n", strlen(arr + 0));
	//6 arr + 0表示首元素地址，与'\0'差6个字符，所以strlen计算长度为6
	printf("%d\n", strlen(*arr)); 
	//错误写法 *arr表示首元素，为字符‘a’，ASCII码是97，strlen会将97当作地址来处理
	//此时会造成越界访问，运行时会报错
	printf("%d\n", str1en(arr[1])); 
	//错误写法 arr[1]表示第二个元素，为字符‘b’，ASCII码是98，strlen会将98当作地址来处理
	//此时会造成越界访问，运行时会报错
	printf("%d\n", strlen(&arr));
	//6 &arr取出数组的地址，strlen在接收地址的时候是char*,会将数组的地址当作char*来使用
	//往后寻找'\0',经过6个char刚好找到\0
	printf("%d\n", strlen(&arr + 1));
	//随机值 &arr + 1跳过数组得到数组后面的地址，什么时候会遇到'\0'不确定，所以是随机值
	printf("%d\n", strlen(&arr[0] + 1));
	//5  &arr[0] + 1表示第二个元素的地址，经过5个char遇到'\0'，所以strlen计算长度为5
	return 0;
}

9.6 *p,"abcdef",sizeof

请写出下面程序执行的结果

#include<stdio.h>
int main()
{
	char* p = "abcdef";
	printf("%d \n", sizeof(p));
	printf("%d\n", sizeof(p + 1));
	printf("%d\n", sizeof(*p));
	printf("%d\n", sizeof(p[0]));
	printf("%d\n", sizeof(&p));
	printf("%d\n", sizeof(&p + 1));
	printf("%d\n", sizeof(&p[0] + 1));
	return 0;
}

详解及结果展示：

#include<stdio.h>
int main()
{
	char* p = "abcdef";
	//指针变量p存放的不是常量字符串"abcdef"本身，而是存放其首元素的地址,
	//即字符串"abcdef"中字符'a'的地址
	printf("%d \n", sizeof(p));
	//4/8 p是一个指针，指针大小32位/64位平台为4/8
	printf("%d\n", sizeof(p + 1));
	//4/8 p+1是一个地址，字符'b'的地址，地址大小为4/8
	printf("%d\n", sizeof(*p));
	//1  *p表示字符'a',类型是char，大小为1个字节
	printf("%d\n", sizeof(p[0]));
	//1  p[0]( 即: *(p+0) )常量字符串第一个元素，即'a',类型是char，大小为1个字节
	printf("%d\n", sizeof(&p));
	//4/8 &p表示取出p的地址，地址大小为4/8
	printf("%d\n", sizeof(&p + 1));
	//4/8 &p+1表示取出p后面的地址，地址大小为4/8
	printf("%d\n", sizeof(&p[0] + 1));
	//4/8 &p[0] + 1表示第二个元素的地址，即'b'的地址，地址大小为4/8
	return 0;
}

9.7 *p,"abcdef",strlen

请写出下面程序执行的结果

#include<stdio.h>
#include<string.h>
int main()
{
	char* p = "abcdef";
	printf("%d\n", strlen(p));
	printf("%d\n", strlen(p + 1));
	printf("%d \n", strlen(*p));
	printf("%d\n", strlen(p[0]));
	printf("%d\n", strlen(&p));
	printf("%d\n", strlen(&p + 1));
	printf("%d \n", strlen(&p[0] + 1));
	return 0;
}

详解及结果展示：

#include<stdio.h>
#include<string.h>
int main()
{
	char* p = "abcdef";
	//指针变量p存放的不是常量字符串"abcdef"本身，而是存放其首元素的地址,
	//即字符串"abcdef"中字符'a'的地址
	printf("%d\n", strlen(p));
	//6 p存储的是'a'的地址，strlen从a开始往后找6个字符，找到'\0'
	//所以strlen计算的字符串长度为6
	printf("%d\n", strlen(p + 1));
	//5 p + 1是'b'的地址,strlen从b开始往后找5个字符，找到'\0'
	printf("%d \n", strlen(*p));
	//错误写法 *p为字符‘a’，ASCII码是97，strlen会将97当作地址来处理
	//此时会造成越界访问，运行时会报错
	printf("%d\n", strlen(p[0]));
	//错误写法 p[0]为字符‘a’，ASCII码是97，strlen会将97当作地址来处理
	//此时会造成越界访问，运行时会报错
	printf("%d\n", strlen(&p));
	//随机值 取出p的地址，传给strlen，strlen在往后寻找'\0',不知道什么时候遇到'\0'
	printf("%d\n", strlen(&p + 1));
	//随机值 取出p后面的地址，传给strlen，strlen在往后寻找'\0',不知道什么时候遇到'\0'
	printf("%d \n", strlen(&p[0] + 1));
	//5 p[0]表示首元素，&p[0]表示首元素地址，&p[0] + 1表示第二个元素'b'的地址
	//strlen从'b'开始计算字符串长度
	return 0;
}

9.8 arr[][],{0},sizeof

请写出下面程序执行的结果

int main()
{
	//二维数组
	int a[3][4] = { 0 };
	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof(a[0][0]));
	printf("%d \n", sizeof(a[0]));
	printf("%d\n", sizeof(a[0] + 1));
	printf("%d\n", sizeof(*(a[0] + 1)));
	printf("%d\n", sizeof(a + 1));
	printf("%d\n", sizeof(*(a + 1)));
	printf("%d\n", sizeof(&a[0] + 1));
	printf("%d\n", sizeof(*(&a[0] + 1)));
	printf("%d\n", sizeof(*a));
	printf("%d \n", sizeof(a[3]));
	return 0;
}

知识储备： 二维数组的数组名表示首元素地址时，首元素指的是第一行数组，也就是说首元素是数组，数组名表示的是第一行数组的地址

详解及结果展示：

#include<stdio.h>
int main()
{
	//二维数组
	int a[3][4] = { 0 };
	printf("%d\n", sizeof(a));
	//3*4*4=48
	printf("%d\n", sizeof(a[0][0]));
	//4
	printf("%d \n", sizeof(a[0]));
	//4*4=16  a[0]相当于第一行作为一维数组的数组名，
	//sizeof(arr[0])把数组名单独放在sizeof()内，计算的是第一行的大小
	printf("%d\n", sizeof(a[0] + 1));
	//4/8   a[0]+1， a[0]放到表达式中了，是第一行作为数组的数组名，此时表示首元素地址
	//a[0]+1表示第一行第二个元素的地址，地址的大小为4/8
	printf("%d\n", sizeof(*(a[0] + 1)));
	//4    a[0]+1表示第一行第二个元素的地址 *(a[0] + 1)表示第一行第二个元素，类型是int
	printf("%d\n", sizeof(a + 1));
	//4/8   a表示首元素地址，把二维数组看作一维数组，a即第一行数组的地址，a + 1表示第二行的地址，地址的大小为4/8
	printf("%d\n", sizeof(*(a + 1)));
	//4*4=16  a + 1表示第二行的地址,*(a + 1)表示第二行数组，数组有4个元素，均为int类型
	printf("%d\n", sizeof(&a[0] + 1));
	//4/8    a[0]放到表达式中了，是第一行作为数组的数组名，此时表示首元素地址
	//&a[0] + 1表示第二行数组的地址，地址的大小是4/8
	printf("%d\n", sizeof(*(&a[0] + 1)));
	//4*4=16   &a[0] + 1表示第二行数组的地址,*(&a[0] + 1)表示第二行数组，数组有4个元素，均为int类型
	printf("%d\n", sizeof(*a));
	//4*4=16   a表示二维数组首元素地址，即第一行数组的地址，*a表示第一行数组，大小为4*4
	printf("%d \n", sizeof(a[3]));
	//4*4=16   假设有第四行的数组，此时第四行数组的大小是4*4=16
	//sizeof操作符()内部不参与`真实运算`，所以实际上没有去越界访问
	return 0;
}

10.指针笔试题

笔试题1：

#include<stdio.h>
int main()
{
	int a[5] = { 1,2,3,4,5 };
	int* ptr = (int*)(&a + 1);
	printf("%d,%d", *(a + 1), *(ptr - 1));
	//程序的结果是什么?
	return 0;
}

2，5

(int*)(&a+1)，这里&a表示数组的地址，然后+1是跳过整个数组大小，
*（a+1）表示首元素地址+1，就是a[2]的地址，然后解引用，就打印2
*(ptr - 1) 表示在跳过一个数组地址后再-1；就得到了没有跳过之前数组的最后一个元素的地址，再进行解引用，就得到了5

笔试题2：

//由于还没学习结构体，这里告知结构体的大小是20个字节
struct Test
{
	int Num;
	char* pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}* p;//p是一个结构体指针变量
 
//X86环境下演示：
//假设p 的值为0x100000。 如下表表达式的值分别为多少？
//已知，结构体Test类型的变量大小是20个字节
int main()
{
	p = (struct Test*)0x100000;//这里是强制把0x100000地址赋值给p
	printf("%p\n", p + 0x1);
        //这里就是给整个结构体地址+1，跳过一个结构体的地址20；0x100014
 
	printf("%p\n", (unsigned long)p + 0x1);
        //就是强制转换为整形+1；0x100001
 
	printf("%p\n", (unsigned int*)p + 0x1);
        //就是强制换行为地址+1，就是加4；0x100004
 
	return 0;
}

笔试题3：

//小端,X86环境
#include<stdio.h>
int main()
{
	int a[4] = { 1,2,3,4 };
	int* ptr1 = (int*)(&a + 1);
	int* ptr2 = (int*)((int)a + 1);
	printf("%x,%x", ptr1[-1], *ptr2);
	return 0;
}


#include<stdio.h>
int main()
{
	int a[4] = { 1,2,3,4 };
	int* ptr1 = (int*)(&a + 1);
	//&a表示取出数组的地址，&a+1表示跳过数组，到数组后面的地址
	//(int*)(&a+1)将这个地址强制类型转换成int*，放到ptr1里面
	int* ptr2 = (int*)((int)a + 1);
	//a表示数组首元素地址，（int）a将这个地址强制类型转换成int类型
	//(int)a + 1,就是地址+1
	//(int*)((int)a + 1)将这个地址强制类型转换成int*，放到ptr2里面
	printf("%x,%x", ptr1[-1], *ptr2);
	//4 ptr[-1]==>*(ptr-1)得到数组最后一个元素，即4，%x八进制打印结果也是4
	//02 00 00 00 *ptr2得到的就是被强制类型转换为int类型的地址的值+1，地址的单位是字节
	//ptr2解引用就是访问 00 00 00 02 （小端字节序存储），打印的时候就是 02 00 00 00
	return 0;
}

笔试题4：

#include<stdio.h>
int main()
{
	int a[3][2] = { (0,1),(2,3),(4,5) };
	int* p;
	p = a[0];
	printf("%d", p[0]);
	return 0;
}

#include<stdio.h>
int main()
{
	int a[3][2] = { (0,1),(2,3),(4,5) };
	//初始化{}内部的( )是逗号表示式，结果是最后一个表达式的结果
	//相当于{1,3,5}
	int* p;
	p = a[0];//a[0]是第一行数组名，没有&，没有单独放到sizeofn（）内，表示首元素地址
	//将二维数组第一行第一个元素的地址赋值给p
	printf("%d", p[0]);//等价*(p+0)
	//1
	return 0;
}

笔试题5：

#include<stdio.h>
int main()
{
	int a[5][5];
	int(*p)[4];
	p = a;
	printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
	return 0;
}

笔试题6：

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

详解及结果展示：

#include<stdio.h>
int main()
{
	int aa[2][5] = { 1,2,3,4,5,6,7,8,9,10 };
	int* ptr1 = (int*)(&aa + 1);
	//&aa + 1 跳过整个数组，指向数组后面的地址
	int* ptr2 = (int*)(*(aa + 1));
	//*(aa + 1) 等价与aa[1]，第二行首元素地址
	printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));
	//10,5
	return 0;
}

笔试题7：

#include<stdio.h>
int main()
{
	char* a[] = { "work","at","alibaba" };
	char** pa = a;
	pa++;
	printf("%s\n", *pa);
	return 0;
}


#include<stdio.h>
int main()
{
    //字符指针数组只存储每个字符串-首字符地址
	char* a[] = { "work","at","alibaba" };
	char** pa = a;
	pa++;
	//pa指向a[1]的地址，a[1]存放"at"常量字符串的首地址
	printf("%s\n", *pa);
	//*pa找到a[1]，打印 at
	return 0;
}

笔试题8：

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


#include<stdio.h>
int main()
{
	char* c[] = { "ENTER","NEW","POINT","FIRST" };
	char** cp[] = { c + 3, c + 2, c + 1, c };
	char*** cpp = cp;
	printf("%s\n", **++cpp);
	//"POINT"
	printf("%s\n", *-- * ++cpp + 3);
  //注:printf里面执行的语句一直存在且生效
  //先看（*++cpp）解引用拿到C+1内容，然后(*--c+1)，内容由（c+1）变成了（c）了，就由c的地址解引用指向"ENTER",最后+3移动3个字节，打印"ER"
	//"ER"
	printf("%s\n", *cpp[-2] + 3);
	//"ST"
	printf("%s\n", cpp[-1][-1] + 1);
	//"EW"
	return 0;
}

相关文章