C语言:《数据的存储》 《指针进阶》《回调函数》《指针的面试题》

数据的存储
1.数据类型的基本归类
1.整形：
char :
unsigned char signed char
short
unsigned short[int] signed short[int]
int
unsigned int signed int
long
unsigned long[int] signed long[int]
2.浮点数：
float double
3.构造类型：
数组类型 结构体类型struct 枚举类型enum 联合类型 union
4,指针类型
int pi; char pc; float pf; void pv;
5.空类型：
void 表示空类型（无类型）
通常应用于函数的返回类型、函数的参数、指针类型。

2.整形在内存中的存储
原码：
直接将二进制数按照正负数的形式翻译成二进制就可以
反码：
将原码的符号位不变，其它依次按位取反就可以得到
补码:
反码+1
对于整形来说：数据存放在内存中其实存放的是补码
原因在于，使用补码，可以将符号位和数值域统一处理； 同时，加法和减法也可以统一处理（CPU只有加法器）此外，补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路

大小端介绍：
大端：是指数据的低位保存在内存的高地址中，而数据的高位，保存在内存的低地址处；
小端：是指数据的低位保存在内存的低地址中，而数据的高位，保存在内存的高地址中。

我们常用的 X86 结构是小端模式，而 KEIL C51 则为大端模式。很多的ARM，DSP都为小端模式。有些ARM处理器还可以由硬件来选择是大端模式还是小端模式。

设计一个程序判断当前机器是大端还是小端：

int check_sys()
{
	int i = 1;
	return(*(char*)&i);
}
int main()
{
	int ret = check_sys();
	if (ret == 1)
	{
		printf("小端");
	}
	else
	{
		printf("大端");
	}
	system("pause");
	return 0;

联合体判断：

int check_sys()
{
	union
	{
		int i;
		int c;
	}un;
	un.i = 1;
	return un.c;
}

联合体内任意一个成员地址在数值上都相等

指针的进阶

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

字符指针

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

是把字符串的首地址放到了pstr中

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

int *p1[10]; 指针数组
int (*p2)[10]; 数组指针

[]的优先级高于*号。

&数组名和数组名

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表示的是数组的地址，而不是数组首元素的地址，数组地址+1，跳过整个数组的大小，所以&arr+1相当于&arr的差值是40

一级指针传参

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);
	system("pause");
	return 0;
}

二级指针传参

void test(int **pp)
{
	printf("num=%d\n", **pp);
}
int main()
{
	int n = 10;
	int *p = &n;
	int **pp = &p;
	test(pp);
	test(&p);
	system("pause");
	return 0;
}

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

qosrt函数的使用者得实现一个比较函数

int int_cmp(const void * p1, const void * p2)
{
	return (*(int *)p1 - *(int *)p2);
}
int main()
{
	int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
	int i = 0;

	qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp);
	for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	system("pause");
	return 0;
}

指针笔试题
1.

int main()
{
	int a[5] = { 1, 2, 3, 4, 5 };
	int *ptr = (int*)(&a + 1);
	printf("%d,%d",*(a+1),*(ptr-1));
	system("pause");
	return 0;
}

输出结果：2, 5

int main()
{
	int a[4] = { 1, 2, 3, 4 };
	int *ptr = (int*)(&a + 1);
	int *ptr2 = (int*)((int)a + 1);
	printf("%x,%x", ptr[-1], *ptr2);
	system("pause");
	return 0;
}

加1的含义是：令指针a指向下一个数据 ，下一个数据是啥？当然是紧挨着的下一个具有4个整型变量的数组了（因为&a的类型是指向具有4个整型变量的数组的指针嘛），于是a的指向了4的下一个地址，在用此值初始化ptr1

由于在ptr1初始化的时候，令&a+1强制转换成整型指针因此ptr1[-1]相当于把ptr1往前挪一个整型大小，即4个字节。 如下图：

(int*)((int)a + 1)
它先是把数组名a强制转换成整型变量，然后再加1，然后再强制转换成整型指针

3.

int a[5][5];
	int(*p)[4];
	p = a;
	printf("%p,%d", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);

a作为二维数组，&a[4][2]相当于 &a[0][0]+4sizeof(int)+2sizeof(int)。

p是一个指向包含4个int型元素的数组的指针，p+1相当于p向后移动4个int类型的元素的数组，就是4sizeof(int)，所以p[4][2]相当于：&a[0][0]+44sizeof(int)+2*sizeof(int)。