0
点赞
收藏
分享

微信扫一扫

c语言---指针进阶

凶猛的小白兔 2022-04-19 阅读 53
c语言

一、字符指针

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

一般使用：

int main()
{
	char ch = 'w';
	char* pc = &ch;
	*pc = 'a';
	printf("%c\n", ch);
	return 0;
}
int main()
{
	const char* p = "abcdef";//常字符串不能直接修改
	//*p = 'w';              //err  出错
	printf("%c\n", *p);      //打印一个字符
	printf("%s\n", p);       //打印一个字符串  只需要把其首地址给出
	return 0;
}

 还有一种使用方式如下：

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

代码 const char* pstr = "hello bit.";特别容易认为是把字符串 hello bit .放到字符指针 pstr 里了，但是本质是把字符串 hello bit. 首字符的地址放到了pstr中。

因此上面代码的意思是把一个常量字符串的首字符 h 的地址存放到指针变量 pstr 中。

面试题举例：

int main()
{
	const char* p1 = "abcdef";  //与const无关 不影响答案
	const char* p2 = "abcdef";

	char arr1[] = "abcdef";//加不加const结果都一样的
	char arr2[] = "abcdef";

	if (p1 == p2)
	{
		printf("p1 == p2\n");
	}
	else
	{
		printf("p1 != p2\n");
	}

	if (arr1 == arr2)
	{
		printf("arr1 == arr2\n");
	}
	else
	{
		printf("arr1 != arr2\n");
	}

	return 0;
}

输出结果是：

二、指针数组

指针数组是一个存放指针的数组。下面指针数组是什么意思？

int main()
{
	//int* arr[10];//存放整型指针的数组
	//char* ch[5]; //存放字符指针的数组

	int a = 10;
	int b = 20;
	int c = 30;
	int* p1 = &a;
	int* p2 = &b;
	int* p3 = &c;

	int* arr[3] = { &a, &b, &c };//arr就是一个指针数组
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		printf("%d ", *(arr[i]));
	}

	return 0;
}
int main()
{
	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* parr[3] = { arr1, arr2, arr3 };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("%d ", parr[i][j]);
			printf("%d ", *(parr[i]+j));
		}
		printf("\n");
	}

	return 0;
}

 三、数组指针

1.数组指针的定义

数组指针是指针？还是数组？ 答案是：指针。

int main()
{
	int a = 10;
	int *p = &a;    //整型指针 - 指向整型的指针， 存放整型变量地址的	
	char ch = 'w';
	char* pc= &ch;  //字符指针 - 指向字符的指针，存放的是字符变量的地址
	return 0; 
}

那数组指针应该是：能够指向数组的指针。

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

3.数组指针的使用

既然数组指针指向的是数组，那数组指针中存放的应该是数组的地址。

#include <stdio.h>
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,0};
    int (*p)[10] = &arr;//把数组arr的地址赋值给数组指针变量p
    return 0;
}

但是我们一般很少这样写代码。

下面写一个函数打印arr数组的内容

//形参写出数组
void print1(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
//形参写成指针的形式
void print1(int* arr, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(arr + i));
	}
	printf("\n");
}
//这不是推荐的写法
void print1(int (*p)[10], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		//*p 相当于数组名，数组名又是首元素的地址，所以*p就是&arr[0]
		printf("%d ", *(*p + i));
	}
	printf("\n");
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	print1(arr, sz);
	return 0;
}

一个数组指针在二维数组的使用：

void print2(int arr[3][5], int c, int r)
{
	int i = 0;
	for (i = 0; i < c; i++)
	{
		int j = 0;
		for (j = 0; j < r; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}

void print2(int(*p)[5], int c, int r)
{
	int i = 0;
	for (i = 0; i < c; i++)
	{
		int j = 0;
		for (j = 0; j < r; j++)
		{
			//p+i是指向第i行的
			//*(p+i)相当于拿到了第i行，也相当于第i行的数组名
			//数组名表示首元素的地址，*(p+i) 就是第i行第一个元素的地址
			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} };
	int (*ptr)[3][5] = &arr;    //数组指针
	print2(arr, 3, 5);
	return 0;
}

 

四、数组参数、指针参数

1.一维数组传参

#include <stdio.h>
void test(int arr[])//对
{}
void test(int arr[10])//对
//数组传参只是传递首元素的地址 并不会创建一个数组 所以这个10有没有都行 没有影响
{}
void test(int *arr)//对
{}
void test2(int *arr[20])//对  这个20和上面一个道理
{}
void test2(int **arr)//对
{}
int main()
{
     int arr[10] = {0};
     int *arr2[20] = {0};
     test(arr);
     test2(arr2);
}

2.二维数组传参

void test(int arr[3][5])//对
{}
void test(int arr[][])//错
{}
void test(int arr[][5])//对  行可以省列不可以省
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。这样才方便运算。
void test(int *arr)//错
{}
void test(int* arr[5])//错
{}
void test(int (*arr)[5])//对
{}
void test(int **arr)//错
{}
int main()
{
     int arr[3][5] = {0};
     test(arr);
}

3.一级指针传参

void test(int* ptr, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *ptr);
		ptr++;
	}
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr;
	int sz = sizeof(arr) / sizeof(arr[0]);
	test(p, sz);//p是一级指针
	return 0;
}
int main()
{
	int arr[3][5];
	test1(arr);//传递的第一行的地址
	test2(&arr);//传递的是整个二维数组的地址
	return 0;
}

 思考：当一个函数的参数部分为一级指针的时候，函数能接收什么参数？

比如：

void test1(int *p)
{}
//test1函数能接收什么参数？
void test2(char* p)
{}
//test2函数能接收什么参数？

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 c = 'b';
     char*pc = &c;
     char**ppc = &pc;
     char* arr[10];
     test(&pc);
     test(ppc);
     test(arr);//Ok?
     return 0;
}

五、函数指针

#include <stdio.h>
void test()
{
     printf("hehe\n");
}
int main()
{
     printf("%p\n", test);
     printf("%p\n", &test);
     return 0;
}

输出结果是：

输出的是两个地址，这两个地址是 test 函数的地址。

int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int arr[10];
	int (*p)[10] = &arr;//p是一个数组指针变量
	printf("%p\n",  &Add);
	printf("%p\n", Add);
	int (* pf)(int, int) = Add;//就是函数指针变量
	int ret1 = (*pf)(2,3);
	int ret2 = Add(2, 3);

	int ret3 = pf(2, 3);
	printf("%d %d %d\n", ret1,ret2,ret3);
	return 0;
}

那我们的函数的地址要想保存起来，怎么保存？

void test()
{
 printf("hehe\n");
}
//下面pfun1和pfun2哪个有能力存放test函数的地址？
void (*pfun1)();
void *pfun2();

首先，能存储地址，就应该知道pfun1和pfun2是不是指针，哪个是指针。

答案是：pfun1可以存放。pfun1先和*结合，说明pfun1是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为void。

int main()
{ 
	//代码1  ( *( void (*)() )0 )();

	void (*)()      //是函数指针类型
	void (*p)()
	( void (*)() )  //  ( 类型 )  格式就是强制类型转换 
	( void (*)() )0 //对0进行强制类型的转换
	//0x0012ff40
	
	( *( void (*)() )0 )();
	//1. 首先是把0强制类型转换为一个函数指针类型，这就意味着0地址处放一个返回类型是void，无参的一个函数
	//2. 调用0地址处的这个函数


	int Add(int, int);  //函数类型声明

	//代码2
	void (* signal(int, void(*)(int)) )(int); //函数声明

	typedef void(* pf_t)(int) ;//给函数指针类型void(*)(int)重新起名叫：pf_t
	pf_t signal(int, pf_t);    //然后就转换为这样的

	//signal是一个函数的声明
	//signal函数的参数，第一个是int类型的，第二个是void(*)(int)的函数指针类型
	//signal函数的返回值类型也是：void(*)(int)的函数指针

	return 0;
}

六、函数指针数组

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

答案是：parr1

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

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

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

int main()
{
	char* arr[5];  //字符指针数组
	int* arr2[4];  //整形指针数组

	int (*pf1)(int, int) = Add;
	int (*pf2)(int, int) = Sub;
	int (*pf3)(int, int) = Mul;
	int (*pf4)(int, int) = Div;
	//函数指针数组
	int (* pf[4])(int, int) = { Add, Sub, Mul, Div };
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		int ret = pf[i](8, 2);
		printf("%d\n", ret);
	}

	return 0;
}

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");
	printf("**************************\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("ret = %d\n", ret);
			break;
		case 2:
			printf("请输入2个操作数:>");
			scanf("%d%d", &x, &y);
			ret = Sub(x, y);
			printf("ret = %d\n", ret);
			break;
		case 3:
			printf("请输入2个操作数:>");
			scanf("%d%d", &x, &y);
			ret = Mul(x, y);
			printf("ret = %d\n", ret);
			break;
		case 4:
			printf("请输入2个操作数:>");
			scanf("%d%d", &x, &y);
			ret = Div(x, y);
			printf("ret = %d\n", ret);
			break;
		case 0:
			printf("退出计算器\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);

	return 0;
}

使用函数指针数组的实现：

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");
	printf("**************************\n");
}
int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	//转移表
	int (*pfArr[])(int, int) = {0, Add, Sub, Mul, Div};
 
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		if (input == 0)
		{
			printf("退出计算器\n");
		}
		else if(input >= 1 && input<=4)
		{
			printf("请输入2个操作数:>");
			scanf("%d%d", &x, &y);	
			ret = pfArr[input](x, y);
			printf("ret = %d\n", ret);
		}
		else
		{
			printf("选择错误\n");
		}

	} while (input);

	return 0;
}

七、指向函数指针数组的指针

指向函数指针数组的指针是一个指针。指针指向一个数组 ，数组的元素都是函数指针 。

void test(const char* str)
{
     printf("%s\n", str);
}
int main()
{
     //函数指针pfun
     void (*pfun)(const char*) = test;
     //函数指针的数组pfunArr
     void (*pfunArr[5])(const char* str);
     pfunArr[0] = test;
     //指向函数指针数组pfunArr的指针ppfunArr
     void (*(*ppfunArr)[5])(const char*) = &pfunArr;
     return 0;
}

八、回调函数

首先演示一下qsort函数的使用：

#include <stdio.h>
//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");
    return 0;
}

使用回调函数，模拟实现qsort（采用冒泡的方式）。

注意：这里第一次使用 void* 的指针，讲解 void* 的作用。

#include <stdio.h>
int int_cmp(const void * p1, const void * p2)
{
    return (*( int *)p1 - *(int *) p2);
}
void _swap(void *p1, void * p2, int size)
{
    int i = 0;
    for (i = 0; i< size; i++)
    {
        char tmp = *((char *)p1 + i);
       *(( char *)p1 + i) = *((char *) p2 + i);
       *(( char *)p2 + i) = tmp;
    }
}
void bubble(void *base, int count , int size, int(*cmp )(void *, void *))
{
    int i = 0;
    int j = 0;

    for (i = 0; i< count - 1; i++)
    {
       for (j = 0; j<count-i-1; j++)
       {
            if (cmp ((char *) base + j*size , (char *)base + (j + 1)*size) > 0)
            {
               _swap(( char *)base + j*size, (char *)base + (j + 1)*size, size);
            }
       }
    }
}
int main()
{
    int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
    //char *arr[] = {"aaaa","dddd","cccc","bbbb"};
    int i = 0;
    bubble(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");
    return 0;
}

九、指针和数组笔试题解析

//一维数组
int a[] = {1,2,3,4};
printf("%d\n",sizeof(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));

//字符数组
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));

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

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

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

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

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

//二维数组
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]));

总结数组名的意义：

十、指针笔试题

笔试题1

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

笔试题2

//由于还没学习结构体，这里告知结构体的大小是20个字节
struct Test
{
     int Num;
     char *pcName;
     short sDate;
     char cha[2];
     short sBa[4];
}*p;
//假设p 的值为0x100000。 如下表表达式的值分别为多少？
//已知，结构体Test类型的变量大小是20个字节
int main()
{
     printf("%p\n", p + 0x1);
     printf("%p\n", (unsigned long)p + 0x1);
     printf("%p\n", (unsigned int*)p + 0x1);
     return 0;
}

输出结果是:

笔试题3

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

笔试题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;
}

笔试题5

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

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

输出结果：10，5

笔试题7

int main()
{
     char *a[] = {"work","at","alibaba"};
     char**pa = a;
     pa++;
     printf("%s\n", *pa);
     return 0;
}

笔试题8

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

举报

相关推荐

C语言指针进阶

c语言

C语言 指针进阶

c语言

[C语言]指针进阶

c语言开发语言后端

C语言——指针进阶

qt开发语言

C语言-指针进阶

指针进阶C语言C/C++后端开发技术人为什么要写博客？

C语言_指针_进阶

c语言开发语言

【C语言进阶】- 指针进阶(2)

c语言c++

C语言进阶：指针的进阶

c语言开发语言

C语言进阶--指针(C语言灵魂)

matlab开发语言算法

C语言——指针进阶（三）

前端框架vue.js前端
0 条评论