C进阶-指针拓展

指针的进步值与指针的运算：

指针变量里面存储的是整数，代表着内存的编号（每个整数都对应着一字节的内存）。

#include <stdio.h>                                                              
void func(int num)
{
    *(int*)num = 6666;
}
​
int main()
{
    int num = 1234;
    func((int)&num);
    printf("%d\n",num);
}

指针的进步值：

指针变量中存储的其实是一个内存块的首地址，内存块的具体大小由指针变量的类型决定，当使用指针变量解引用访问内存时，实际访问的内存字节数叫做指针变量的进步值，也就是指针变量+1后的内存地址的变化。

#include <stdio.h>                                                              
int main()
{
    char* p1 = NULL;
    short* p2 = NULL;
    int* p3 = NULL;
    long long* p4 = NULL;
    long double* p5 = NULL;
    printf("%p %p %p %p %p\n",p1,p2,p3,p4,p5);
    printf("%p %p %p %p %p\n",p1+1,p2+1,p3+1,p4+1,p5+1);
}

指针的运算：

指针变量存储就是是整数，理论上整数能使用的运算符，指针变量都可以使用，但只有以下运算才有意义：

指针+n = 指针所代表的整数+进步值*n       
指针-n = 指针所代表的整数-进步值*n
指针1-指针2 = (指针1所代表的整数-指针2所代表的整数)/进步值 

指针加减整数，就相当于以指针变量的进步值为单位前后移动，指针-指针可以计算出两个指针变量之间相隔多个元素。

#include <stdio.h>
​
int main()
{
    int arr[10];
    int* p1 = &arr[0];
    int* p2 = &arr[9];
    printf("%p %p\n",p2,p1);
    printf("%d\n",p2-p1);                                                       
}

注意：

指针-指针运算，它们的类型必须相同，否则编译器会报错。

数组名与指针：

数组名就是指针：

1、数组名就是数组内存块的首地址，它是个常量地址（特殊的指针），所以它作函数的参数时，才能蜕变成指针变量。

#include <stdio.h>
​
void show_arr(int* arr,size_t len)
{
    // 地址
    printf("%p\n",arr);
    for(int i=0; i<len; i++)
    {
        // *(arr+i) <=> arr[i];
        printf("%d\n",arr[i]);
    }
}
​
int main(int argc,const char* argv[])
{
    // 地址 常量 数组
    int arr[] = {1,2,3,4,5,6};
    
    printf("%p\n",arr);
    printf("%d\n",sizeof(arr)/sizeof(arr[0]));
    show_arr(arr,6);
    for(int i=0; i<6; i++)
    {
        printf("%d ",*(arr+i));
    }
}

2、指针变量可以使用[]解引用，数组名也可以*遍历，它们是等价的。

#include <stdio.h>
​
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    for(int i=0; i<10; i++)
    {   
        // 指针[i] <=> *(指针+i)
        printf("%d %d\n",arr[i],*(arr+i));                                      
    }   
}

注意：

如果定义<TYPE> arr[n]数组，数组名arr 就是 TYPE*类型的地址。

数组名与指针的相同点：

1、它们都是地址

2、它们都使用[],*去访问一块连续的内存

数组名与指针的不同点：

1、数组名是常量，而指针是变量

2、指针变量有它自己的存储空间，而数组名就是地址，它没有存储地址的内存。

3、指针变量与它的目标内存是指向关系，而数组名与它的目标内存是映射关系。

#include <stdio.h>
​
void show_arr(int arr[],size_t len)
{
    printf("show:%p %p\n",arr,&arr);
}
​
int main(int argc,const char* argv[])
{
    int arr[] = {1,2,3,4,5,6};
    printf("main:%p %p\n",arr,&arr);
    show_arr(arr,6);
}

通用指针：

我们一些通用的操作函数，它们的参数可能是任意类型的指针，但编译器规定不同类型的指针不能进行赋值，为了兼容各种类型的指针，C语言中设计了void类型的指针，它能与任意类型的指针互相转换，它能解决不同类型的指针参数的兼容性问题。

void* p1;
// void* 可以给任意类型的指针变量赋值
int* p2 = p1;
// 任意类型的指针可以给void*类型的指针赋值
void* p3 = p2;

通用操作的函数：

void bzero(void *s, size_t n);
功能：把内存块s的n个字节，赋值为0。
    
void *memset(void *s, int c, size_t n);
功能：把内存块s的n个字节，赋值为c(0~255)
    
void *memcpy(void *dest, const void *src, size_t n);
功能：从src内存块拷贝n个字节的内容到dest内存块
    
int memcmp(const void *s1, const void *s2, size_t n);
功能：比较s1和s2内存块的n个字节
    s1 > s2 返回1
    s1 < s2 返回-1
    s1 == s2 返回0

注意：

void类型的指针变量的进步值是1。

void类型的指针变量不能解引用 ，必须转换成其它类型的指针才能解引用。

const与指针：

const int * p;
功能：保护指针变量所指向的内存不被*p修改，或者说不能对 *p 赋值
​
int const * p;
功能：同上
    
int* p1 = p; // 编译时会有警告

由于指针的使用存在一定的风险，所以函数的参数只要是指针，并且函数没有修改指针所指向的内存的需求，我们就应该给指针变量加上const 类型* 指针变量。

int * const p;
功能：保护指针变量p不被修改
    
const int * const p;
功能：既保存指针变量p不被修改，也保护指针变量指向的内存*p不被修改
    
int const * const p;
功能：同上
    
const int num;
// 指向const修饰的变量时，指针变量要用const修改，否则编译会有警告
const int* p = #

当使用数组作函数的参数时，数组就蜕变成了指针变量，为了防止指针改变指向导致数组无法使用，理论上我们应该使用 类型* const 指针变量 防止指针变量改变指向。

与堆内存配合的指针变量也应该从一而终，这样定义 类型* const 指针变量 防止指针变量改指向，从面导致堆内存无法释放（防止产生内存泄漏）。

二级指针：

什么是二级指针：

一级指针存储的是普通变量的内存地址，二级指针存储的是指针变量内存地址。

定义二级指针：

类型* 一级指针;

类型** 二级指针;

注意：二级指针在使用方法上与一组指针不同，所以一般以pp结尾，让使用者从变量名上就

能区别一级指针与二级指针。

二级指针的赋值：

二级指针 = &一级指针;

注意：给二级指针赋值的一级指针，它们的类型必须相同，否则编译时就会报错。

二级指针解引用：

二级指针 = &一级指针;

*二级指针 此时它等价于一级指针

**二级指针 此时它等价于 *一级指针

#include <stdio.h>

int main()
{
    int num = 1234;
    int num1 = 4567;
    int* p = &num;
    int** pp = &p; 

    *pp = &num1; // p = &num1;
    printf("%d\n",*p);
    **pp = 123456789; // num1 = 123456789;
    printf("%d\n",num1);   
}

二级指针的用处：

只有一个情况适合使用二级指针，那就是跨函数共享一级指针变量。

指针数组与数组指针：

什么是指针数组：

由指针变量构成的数组，也可以说它的身份是数组，成员是指针变量。

定义指针数组：

类型* 数组名[n];

就相当于定义了n个指针变量。

int* arr[10]; // 相当于定义了10个int*的指针变量

指针数组的用处：

1、构建不规则二维数组。

2、构建字符串数组。

#include <stdio.h>

int main()
{
    int arr1[] = {6,1,2,3,4,5,6};
    int arr2[] = {3,1,2,3};
    int arr3[] = {5,1,2,3,4,5};
    int arr4[] = {4,1,2,3,4};

    int* arr[] = {arr1,arr2,arr3,arr4};

    for(int i=0; i<4; i++)
    {
        for(int j=1; j<=arr[i][0]; j++)
        {
            printf("%d ",arr[i][j]);
        }
        printf("\n");
    }
}

什么是数组指针：

专门指向数组的指针变量，它的进步值是整个数组的字节数。

定义数组指针：

类型 (*指针变量名) [n];

类型和n决定了 数组指针 指向的是什么样的数组。

#include <stdio.h>

int main()
{
    int arr[5] = {1,2,3,4,5};
    int (*p)[5] = &arr;
    /*
    arr <=> *p
    arr[i] <=> (*p)[i]
    *(arr+i) <=>*((*p)+i)
    */
    
    // 输入结果是20
    printf("%d\n",((int)(p+1))-((int)p));                                       
    printf("%p %p %d\n",p,p+1,*((int*)((int)(p+1)-4)));
}

数组指针的用处：

#include <stdio.h>

int main(int argc,const char* argv[])
{
	int arr[4][5] = {
		{11,12,13,14,15},
		{21,22,23,24,25},
		{31,32,33,34,35},
		{41,42,43,44,45}
	};


	/*
	int* p = (int*)arr;
	for(int i=0; i<20; i++)
	{
		printf("%d ",p[i]);
		if(0 == (i+1)%5)
			printf("\n");
	}
	*/

	int (*p)[4] = (void*)arr;;
	for(int j=0; j<5; j++)
	{
		for(int i=0; i<4; i++)
		{
			//printf("%d ",*((*(p+j))+i));
			printf("%d ",p[j][i]);
		}
		printf("\n");
	}
}

#include <stdio.h>
// 使用数组指针可以把一块连续的内存当作二维数组使用，特别是与堆内存配合效果更佳
int main()
{
    int arr[20] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
    int (*p)[5] = (void*)arr;                                                   
    for(int j=0; j<4; j++)
    {
        for(int i=0; i<5; i++)
        {
            //printf("%d ",*(*(p+j)+i));
            printf("%d ",p[j][i]);
        }
        printf("\n");
    }
}

数组名、指针、数组指针：

int arr[n];
arr 是 int*类型 
*arr 是 int 类型
&arr[0] 也是 int*类型
&arr 是 int (*)[n]类型 
arr[i] <=> *(arr+i)
    
int arr2[row][col];
arr2 是 int (*)[col]类型
*arr2 是 int* 类型
	&arr 是 int (*)[n]类型
    int (*p)[n] = &arr;
	*p <=> arr
**arr2 是 int 类型  
arr2[i][j] <=> *(*(arr2+i)+j)
&arr2[0] 是 int (*)[col]类型
        *(arr2+0) <=> arr2[0]
        &*(arr2+0) <=> &arr2[0]
        &*(arr2+0) <=> arr2+0
&arr2[0][0] 是 int* 类型

函数指针：

函数名是什么：

函数就是一段具有某项功能的代码，它会被编译器编译成二进制指令存储在text内存段，函数名就是它在text内存段的首地址。

#include <stdio.h>

void func(void)
{
    printf("我是函数func,我被调用了...\n");
}

int main()
{
    printf("%p\n",func);
    int num = 0x804843b;
    ((void(*)(void))num)();                                                     
}

什么是函数指针：

专门存储函数地址的指针变量叫函数指针。

定义函数指针：

1、先确定指向的函数的格式(函数声明)。

2、照抄函数声明。

3、用小括号包含函数名。

4、在函数名前加*

5、在函数名末尾加_fp，防止命名冲突。

, 6、用函数名给函数指针赋值后，函数指针就可以当作函数调用了。

#include <stdio.h>

void func(void)
{
    printf("我是函数func,我被调用了...\n");
}

int main()
{
    void (*func_fp)(void) = func;
    func_fp();  
}

函数指针的用处：

函数指针可以让函数像数据一样在函数之间传递。

当我们实现一个数组的排序函数时，那么排序函数内部需要调用数组元素的比较函数，由于我们不知道待排序的数组是什么类型，也就无法自己实现数组元素的比较函数，那么我们可以在排序函数的参数列表中预留一个函数指针，当有人调我们的排序函数时，他就需要提供一个数组元素比较函数供我们调用，排序函数就可以为它的数组进行排序。

函数的这种调用模式就叫回调模式。

void qsort(void *base, 
           size_t nmemb, 
           size_t size,
           int (*compar)(const void *, const void *));
功能：为数组进行排序
base：数组的首地址
nmemb：数组的长度
size：数组成员的字节数
compar：调用者需要提供的数组元素的比较函数

#include <stdlib.h>

int intcmp(const void* p1,const void* p2) 
{
    if(*(int*)p1 > *(int*)p2)
        return 1;                                                         
    if(*(int*)p1 < *(int*)p2)
        return -1; 
    return 0;
}

int main()
{
    int arr[100];
    for(int i=0; i<100; i++)
    {   
        arr[i] = rand() % 100;
    }   

    qsort(arr,100,4,intcmp);

    for(int i=0; i<100; i++)
    {   
        printf("%d ",arr[i]);
    }   
}