C语言 - 指针

最新推荐文章于 2024-06-08 21:16:51 发布
最新推荐文章于 2024-06-08 21:16:51 发布
阅读量539 收藏 2
点赞数
文章标签： c语言 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hhhh_Jy/article/details/126582433
版权

指针

指针是内存中一个最小单元 (1个字节) 的编号 (地址)

指针变量

用来存放地址的变量

指针的大小在32位机器和64位机器是不同的

32位机器 - 32根地址线 - 会产生32个0/1组成的二进制序列 -作为内存单元的标号

64位机器 - 64根地址线 - 会产生64个0/1组成的二进制序列 -作为内存单元的标号

指针类型

指针变量的定义方式就是：类型 + * + 变量名

如： int* p, * 说明变量p是一个指针变量，int表示这个指针变量是指向int型的

不同类型的指针变量有不同的作用

测试1：

#include<stdio.h>
int main()
{
	int a = 0x11223344;

	int* p = &a;
	*p = 0;

	printf("%x\n", a);
	return 0;
}

 测试2：

#include<stdio.h>
int main()
{
	int a = 0x11223344;

	char* p = &a;
	*p = 0;

	printf("%x\n", a);
	return 0;
}

测试1和测试2的不同点是指针变量的类型不同

测试1的指针类型是int*型，将指针变量解引用访问权限是4个字节，因此在赋值为0时事实上是将0赋给这个整型变量a

测试2的指针类型是char*型，将指针变量解引用访问权限是1个字节，由于是小端存储，因此在赋值时将第一个字节存储的数据0x44赋为0，而对其它3个字节的数据并没有修改

因此，指针的类型决定了对指针解引用的时候访问权限的大小（能操作的字节大小）

测试3：

#include<stdio.h>
int main()
{
	int a = 10;

	int* pi = &a;
	char* pc = &a;

	printf("%p\n", pi);
	printf("%p\n", pc);

	printf("%p\n", pi + 1);
	printf("%p\n", pc + 1);

	return 0;
}

pi是整形指针，加1后指向的地址向后移动了4个字节，加n后指向的地址向后移动了n*sizeof(int)个字节

pc是字符指针，加1后指向的地址向后移动了1个字节，加n后指向的地址向后移动了n*sizeof(char)个字节

因此，指针类型决定指针向前或向后走一步走多大距离（多少字节）

野指针

野指针是指针指向的位置不可知的（随机的、不正确的、没有明确限制的）指针变量

野指针的成因：

1.指针未初始化

#include<stdio.h>
int main()
{
	int* p;
	//指针变量未初始化
	*p = 5;
	return 0;
}

此时编译会报错

2.指针越界访问

#include<stdio.h>
int main()
{
	int arr[10] = { 0 };

	//指针变量指向数组首元素arr[0]
	int* p = arr;
	int i = 0;
	for (i = 0; i < 11; i++)
	{
		//当i=10时就会产生数组越界
		*p = 1;
		p++;
	}
	return 0;
}

3.指针指向的空间释放

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	{
		;
	}
	//分配的内存空间被释放
	free(p);

	*p = 0;
	return 0;
}

规避野指针的方式：

1.初始化指针

2.小心数组越界

3.当指针指向的空间被释放后直接将指针置NULL

4.避免返回局部变量地址

5.指针使用前检查有效性

指针-指针

指针-指针 = 指针和指针之间的元素个数

前提是两个指针必须指向同一块空间

#include<stdio.h>
int main()
{
	int arr[10] = { 0 };

	printf("%Id\n", &arr[9] - &arr[0]);

	printf("%Id\n", &arr[0] - &arr[9]);

	return 0;
}

二级指针

存放一个指针变量地址的指针变量

#include<stdio.h>
int main()
{
	int a = 5;
	//一级指针
	int* pa = &a;
	//二级指针
	int** ppa = &pa;
	printf("%p\n", pa);
	printf("%p\n", ppa);

	return 0;
}

 

指针数组 

 指针数组是一个存放指针的数组

#include<stdio.h>
int main()
{
	int d1[] = {1,2,3,4,5};
	int d2[] = {6,7,8,9,10};
	int d3[] = {11,12,13,14,15};

	//指针数组
	int* arr[3] = { d1,d2,d3 };
	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;
}

字符指针

#include<stdio.h>

int main()
{
	char c = 'w';
	char* p1 = &c;
	*p1 = 'a';
	printf("%c\n", c);

	//p2指向字符串常量，字符串常量不能修改，因此指针也加const
	//char* p2 = "ImpEvday";
	const char* p2 = "ImpEvday";
	//*p2 = 'a';	//err
	printf("%c\n", *p2);
	printf("%s\n", p2);
	return 0;
}

程序运行结果：

指针p2指向常量字符串，常量字符串在内存中存储在常量区，不可被修改，字符指针p2指向常量字符串的第一个字符，字符串在内存中连续存放，因此可以通过p2找到这个字符串的后续字符

数组指针

数组指针是能够指向数组的指针

与指针数组区别

int* p1[10]

是指针数组，p1先与[10]结合，表示p1是一个数组，数组有10个元素，int*表示每个元素是int*型

int (*p2)[10]

是数组指针，p2先与*结合，表示p2是一个指向数组的指针，指向的数组有10个元素，每个元素的类型是int，int(*)[10]是这个指针的类型

int (*p3[10])[3]

是指针数组，数组有10个元素，每个元素的类型是int(*)[3]

#include<stdio.h>
int main()
{
	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };

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

arr和&arr[0]都表示数组首元素的地址，加1后指针向后移动一个int型的字节(4个字节)

&arr表示整个数组的地址，加1后指针向后移动一个数组的字节(40个字节)

虽然arr，&arr[0] 和 &arr的地址相同，但其实前两者和后者的意义并不相等

#include<stdio.h>
int main()
{
	int arr1[10] = { 0,1,2,3,4,5,6,7,8,9 };
	//p1是一个指针，类型是int [10]，指向了一个有10个元素，每个元素是int型的数组
	int(*p1)[10] = &arr1;

	int d1[] = {1,2,3};
	int d2[] = {2,3,4};
	int d3[] = {3,4,5};
	//arr2是一个指针数组
	int* arr2[3] = { d1,d2,d3 };

	//p2是一个指针，类型是int* [3]，指向了一个有3个元素，每个元素是int*型的数组
	int* (*p2)[3] = &arr2;
	
	return 0;
}

一个数组的地址要用数组指针来存储

函数指针

函数指针是能够指向函数的指针

#include<stdio.h>

int Add(int x, int y)
{
	int z = x + y;
	return z;
}

int main()
{
	//函数指针
	int (*p)(int, int) = Add;

	//函数名和&函数名都是函数地址
	printf("%p\n", Add);
	printf("%p\n", &Add);

	//以下三种形式都可以调用函数
	int ret1 = Add(2, 3);
	int ret2 = (*p)(2, 3);
	int ret3 = p(2, 3);

	return 0;
}

代码解析

//代码1 (*(void (*) () ) 0 ) ();

void (*) ()是函数指针类型，(类型)表示强制类型转换，(void (*) () ) 0 对0进行强制类型转换为一个函数指针类型，代表0地址处存放一个返回类型是void，无参的一个函数，(*(void (*) () ) 0 ) ();调用0地址处的这个函数

//代码2 void (*signal(int , void(*)(int)))(int);

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

函数指针数组

#include<stdio.h>

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

int Sub(int x, int y)
{
	return x - y;
}

int main()
{
	//函数指针
	int(*p1)(int, int) = Add;
	int(*p2)(int, int) = Sub;

	//函数指针数组
	int(*pa[2])(int, int) = { p1,p2 };

	//指向函数指针数组的指针
	int(*(*pp)[2])(int, int) = &pa;

	return 0;
}

回调函数

回调函数是一个通过函数指针调用的函数，将函数的指针作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，就说这是回调函数

#include<stdio.h>

//此时print就是回调函数
void print()
{
	printf("Go!\n");
}

void test(void (*p)())
{
	p();
}

int main()
{
	test(print);
	return 0;
}

qsort函数

void qsort (void* base,        //要排序数组的起始位置
                  size_t num,        //数组的元素个数
                  size_t size,       //一个元素的字节大小

                  int (*compar)(const void*e1,const void*e2))        //e1,e2为待比较的两个元素地址

                  //比较函数(用户自己定义)

当e1位置的元素>e2位置的元素，返回值大于0

当e1位置的元素=e2位置的元素，返回值等于0

当e1位置的元素<e2位置的元素，返回值小于0

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef struct Peo
{
	char name[20];
	int age;
}Peo;

//比较整型变量大小
int cmp1 (const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2;
}

//比较结构体变量大小
int cmp2(const void* e1, const void* e2)
{
	//比较字符串用strcmp函数
	return strcmp(((Peo*)e1)->name, ((Peo*)e2)->name);
}

int main()
{
	//要将数组排序为升序
	int arr1[10] = { 9,8,7,6,5,4,3,2,1,0 };

	Peo arr2[3] = { {"wang",20},{"yang",1},{"feng",17} };
	
	Peo* p = arr2;

	int sz1 = sizeof(arr1) / sizeof(arr1[0]);

	int sz2 = sizeof(arr2) / sizeof(arr2[0]);

	qsort(arr1, sz1, sizeof(arr1[0]), cmp1);

	qsort(arr2, sz2, sizeof(arr2[0]), cmp2);


	int i = 0;
	for (i = 0; i < sz1; i++)
	{
		printf("%d ", arr1[i]);
	}
	printf("\n");

	for (i = 0; i < sz2; i++)
	{
		printf("%s %d ", (p + i)->name, (p + i)->age);
	}

	return 0;
}

模拟实现qsort函数 

#include<stdio.h>

void swap(char* p1, char* p2, size_t width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *p1;
		*p1 = *p2;
		*p2 = tmp;
		p1++;
		p2++;
	}
}

int cmp(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2;
}

void my_qsort(void* p, size_t n, size_t width, int (*cmp)(const void*, const void*))
{
	//采用了冒泡排序实现qsort
	int i = 0;
	for (i = 0; i < n - 1; i++)
	{
		int j = 0;
		for (j = 0; j < n - i - 1; j++)
		{
			//一个内存单元是一个字节，是char类型所占字节数，将指针变量强制转换为char*
			//强制转换后加1就向后偏移一个字节，如果是整型数组，那么width应等于4，那么指针就每次向后偏移4个字节了
			if (cmp((char*)p + j * width, (char*)p + (j + 1) * width) > 0)
			{
				swap((char*)p + j * width, (char*)p + (j + 1) * width, width);
			}
		}
	}
}


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

	int sz = sizeof(arr) / sizeof(arr[0]);

	my_qsort(arr, sz, sizeof(arr[0]), cmp);

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

运行结果

 

ImpEvday_Wang
关注
C语言之字符指针
m0_64365419的博客
07-10 5441
第一种：指向一个字符 第二种：指向一个数组 第三种：指向一个字符常量 对于char*ch="hello,world"这行代码，很多小伙伴会认为是把hello，world放到字符指针ch里面，但其实是把字符串hello，world，首字符的地址放到了ch中. ......
char *指针的详细解释
热门推荐
季风博客
06-12 2万+
前段时间写了一篇char*和char[]的区别，今天对char*做个更深的理解 1：char指针和其他指针一样，也是定义了一块地址，如int*定义了一块栈，4个字节，char*呢，现在写一段代码 #include using namespace std; int main() { int a=12; char b='67'; int *c=&a; char *d=&b; return
C语言char指针的使用
m0_61545891的博客
01-21 5737
在c语言中，char指针不仅能指向char变量，还能指向常量字符串，同时也能指向一个char数组的。 想要访问单个字符，就要通过*来进行解引用，若是要访问整个数组或字符串的话，就直接输入地址。 但是注意，再上图中b指向的内容时不可改变的，c指向的是可以改变的。 因为b指向的是个常量字符串，是不可改变的，而c指向的是个数组，是可以改变的。 程序运行到*c='a'时未报错，但是到了*b=‘w’时确保错了。 拿一道题目 请问运行结果时什么？ 可以分析，在str1和str2中分别存放了两...
c语言char 指针,C语言指针这些使用技巧值得收藏！
weixin_39655981的博客
05-19 706
C语言的学习过程中，作为C语言的灵魂指针如果用的好犹如神助，用不好会让你叫苦连连，但大多数人是用不好指针的，所以后来的很多语言都把指针封装，屏蔽。比如Java，java是没有指针的，但是很多地方都用到指针，不过不对用户开放，语言的自身机制帮用户处理指针的分配释放，为的就是方便用户使用，减少错误。不过我们不能因噎废食，指针虽难，但学好了会大大提升你的编程能力。下面来列举一下在学习过程中指针的常见错误...
C语言指针
Raymood_的博客
03-12 2647
指针 数组指针 指针数组 函数指针 函数指针数组 指向函数指针数组的指向 回调函数
C语言-指针总结-经典讲解共30页.pdf.zip
11-21
《C语言-指针总结-经典讲解》是深入理解C语言指针的重要参考资料，它涵盖了指针的基础概念、操作及高级应用，对于学习和提升C语言编程能力具有极高的价值。在C语言中，指针被视为一种强大的工具，能够直接操控内存，...
C语言-指针用法详解.pdf
11-14
在C语言中，指针是其强大的特性之一，它允许程序员直接操作内存地址，从而实现高效的数据处理和灵活的程序设计。以下是对标题和描述中所述知识点的详细讲解： 1. **什么是指针？** - 指针是C语言中的一个数据类型...
C语言-指针及测试代码
08-04
以上就是关于C语言指针的基本知识点。理解并熟练运用指针是成为C语言高手的关键。在实际编程中，应注重指针的安全性，避免野指针和内存泄漏等问题，以保证程序的稳定性和效率。通过编写和测试代码，可以更深入地理解...
C语言-指针.pdf
11-23
在C语言的学习过程中，指针是一个非常重要且复杂的话题，它允许程序直接访问内存地址，进行更为底层和高效的内存管理。本文将详细介绍C语言中指针的概念、使用方法，以及如何快速掌握这一重要知识点。 首先，我们...
c语言char类型指针,C语言 char*类型指针习题
weixin_31088435的博客
05-22 346
我用了很笨的方法#include int Comp(char *str1,char *str2){do{if(*str1!=*str2){if(*str1return 1; //str1elsereturn 0;}str1++;str2++;}while(*str1 !='\0' && *str1 !='\0');if(strlen(str1)return 1;elseretur...
C语言进阶——指针
小李很执着的博客
10-12 214
/整形指针的数组//一级字符指针的数组//二级字符指针的数组指向数组的指针-存放数组的地址数组指针存放的是数组的地址，而非数组本身数组名的理解数组名是数组首元素的地址但是存在2个例外：1. sizeof(数组名)，这里的数组名表示整个数组，sizeof(数组名)计算的是整个数组的大小，单位是字节2. &数组名，这里的数组名表示整个数组，取出的是数组的地址数组传参,形参是可以写成数组形式的!数组传参的木质是,传递了数组首元素的地址数组传参,形参也可以是指针!以下形式都正确。
c语言中指针详解
2301_76689430的博客
06-10 351
字符指针（char*）“abcdef”是一个常量字符串（不能被改变），p中存储的是a的地址（首字符的地址）指针数组 （是数组，用来存放指针的）int main()//整形数组//字符数组//存放整形指针的数组--指针数组//存放字符指针的数组--指针数组return 0；arr----指首元素的地址&arr----指数组的地址数组指针 （是指针，用来存放数组地址的）//p是整形指针--指向整形的指针，可以存放整形的地址。
C语言指针详解（1）
weixin_69283129的博客
07-19 1478
C语言指针定义，指针类型的意义，野指针的存在与避免措施
char指针
weixin_33720078的博客
01-11 3780
1、在C语言中，没有字符串类型，因此使用char指针表示字符串。 2、那么问题来了，使用char* 表示字符串，到哪里是结尾呢？因此需要一个特殊的字符作为哨兵，类似迭代器中的end()，这个哨兵就是'\0'，注意不是字符0. 3、对于文本字符串，编译器会自动添加\0。 4、对于字符数组的赋值，如果不使用文本字符串，需要用户在尾部添加字符\0。对于其他类型的数组，没有\0的概念。 5、对于c...
C语言-----初阶指针详解
zxf123567的博客
03-23 1349
此文为博主初次学习指针时记录的笔记，如有错误请批评指正。 1指针是什么？ 内存被划分为一个一个很小的单元，为了方便访问，就对这些最小的单元进行了编号，这些编号就是地址也叫指针。（最小单元为字节）可以利用地址快速的找到的所指向的内存空间。 注： 1，指针是内存中一个最小单元的编号，也就是地址。 2，平时口语中说的指针，通常是指针变量，是用来存放内存地址的变量。 指针变量： 我们可以通过&（取地址操作符） 取出变量占内存首字节的地址，把地址存放到一个变量中，这个变量就是指针变量。 指针变
[文章] 有关char指针的文章一篇 (转)
csd3176的博客
12-12 195
[文章] 有关char指针的文章一篇 (转)[@more@][文章] 有关char指针的文章一篇 先看以下代码: char *p; p="abc"; 你认为是对的吗? 答案：语法上是对的，但不提倡这种写法。 误区1：没有给p...
char* 指针
wddpfx的博客
02-03 1107
对于字符类型的指针真的有很多很多要注意的地方，而且他是String，CString等各种字符串相互转换的桥梁。 使用上稍不注意就会出错。 1.初始化 char* pstr = "hello world.";这是一个指向字符串常量的指针，也就是说hello wrold.是不能被修改的。因为它存储在程序内存中的常量区。很多时候不注意就把pstr当做参数传递了。 所以我们初始化需要改变的字符串时应该使用： char pstr[] = "hello world."; 此时的pstr也可以看做指针，hell.
10-指针进阶——char型，多级指针，void指针，const指针
最新发布
everything is possible，anything is OK.
06-08 997
10-指针进阶——char型，多级指针，void指针，const指针
指针—— char p[] 和 char *p
Hi海底的博客
03-25 6591
目录 1.char p[]和char *p ☆☆☆☆ 2. 3. 函数里的指针** 4.数组作为函数参数传递 5.两数交换的那些坑 6.函数参数为指针应小心 7. 数组指针 ** 8. 二级指针 9.*p++、 (*p)++、 *++p、 ++*p c语言-数组、指针面试题 - CYYZ古月 - 博客园☆☆☆☆☆☆ char *p="abc" 与 char p[]="abc" 的区别_安徽祝子的博客-CSDN博客 C++ 常量 | 菜鸟教程 1.c...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值