指针详解(笔记)

目录

一、const修饰指针

问:被const是否修饰的变量是否有其他方法修改值?

问:被const修饰后,变量是否变成了常量?

1.const放在*的左边

2.const放在*的右边

由上述两段代码可以看出:

二、指针运算

2.1指针与整数的运算

2.2指针与指针的运算

2.3指针的关系运算

三、数组名的理解​

四.使用指针访问数组

五、一维数组的本质

六、传址调用和传值调用

6.1模拟strlen函数

6.2为什么有传址和传值两种调用方式


初识指针(笔记)-CSDN博客

指针详解(二)-CSDN博客

指针详解 冒泡排序 qsort(三)-CSDN博客

一、const修饰指针

const修饰指针       const(常量,不变)

问:被const是否修饰的变量是否有其他方法修改值?

答:可以通过指针的方式绕过a修改其值

int main()
{
	const int a = 10;
	int* pa = &a;//虽然说对a进行了限制,但是此处绕过了a,去修改值
	*pa = 0;//虽然达到了效果,但是操作有点不合理
	printf("%d\n", a);
	return 0;
}
问:被const修饰后,变量是否变成了常量?

答:并不是

int main()
{
	const int a = 10;//a不能被修改了,但是a的本质还是变量
	a = 20;//const仅仅是语法上做出了限制,习惯上叫常变量	修改-err
	printf("a = %d\n", a);
	return 0;
}

const修饰指针的时候
1.const可以放在*的左边
2.const可以放在*的右边

1.const放在*的左边
int main()
{
	const int a = 10;
	int const* p = &a;	 //限制的是*p
	//意思是不能通过p来修改p指向的空间的内容

	//*p = 0;//err,报错
	int b = 20;
	p = &b;//ok

	return 0;
}

2.const放在*的右边
int main()
{
	const int a = 10;
	int *const p = &a;//const限制的是p,也就是p变量不能被修改,没办法指向其他变量,
	//但是*p不受限制,还是可以通过p来修改p所指向的变量
	 
	*p = 0;//ok
	int b = 20;
	//p = &b;//err,报错
	printf("a = %d\n", a);

	return 0;
}
由上述两段代码可以看出:

1.p里面存放的是地址(a的地址)
2.p是变量,有自己的地址
3.*p是p指向的空间

4.const放在*的左边,限制的是*p,意思是不能通过修改指针变量p修改p指向空间的内容。
*p = 20;//err
但是p是不受限制的      p = &b;//ok


5.const放在*的右边限制的是p变量,也就是p变量不能被修改了,没法指向其他变量了。
p = &b;//err
但是*p不受限制,还是可以通过p来修改p所指向的对象的内容。
*p = 20;//ok

二、指针运算

指针的基本运算有三种:
1、指针 +- 整数
2、指针 +- 指针
3、指针的关系运算

2.1指针与整数的运算

在下例中,指针p加一是指向数组的下一个元素

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	//使用指针打印数组的内容
	int* p = &arr[0];
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		//printf("%d", *p);
		//p++;//指针加整数
		printf("%d\n", *(p + i));//p+i加的是i * sizeof(int)
	}
	//p = 00000098240FF5D4
	//p+0 = 00000098240FF5D4
	//p+1 = 00000098240FF5D8

	return 0;

}
2.2指针与指针的运算

指针减去指针的得到的是他们之间的元素个数的绝对值
指针-指针运算的前提条件的:两个指针指向同一块空间

int main()
{
	//指针 - 指针 = 地址 - 地址
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

	printf("%d\n", &arr[0] - &arr[9]);//  |9| 
	char ch[20] = { 0 };
	printf("%d\n", &ch[0] - arr[0]);//err


	return 0;
}
2.3指针的关系运算

其实就是地址的比大小

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);//10
	int* p = &arr[0];
	//arr是数组名,数组名其实是数组首元素的地址,arr <==>&arr[0]
	while (p < arr + sz)//使用while循环打印arr的数组
	{
		printf("%d", *p);
		p++;
	}
	return 0;
}

三、数组名的理解​

int main()
{
 int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
 printf("&arr[0] = %p\n", &arr[0]);
 printf("arr = %p\n", arr);
 return 0;
}

根据上述代码输出结果,我们发现数组名和数组首元素的地址打印出的结果一模一样,数组名就是数组首元素(第一个元素)的地址。

int main()
{
	int arr[10] = { 0 };
	printf("%d\n", sizeof(arr));
    
	printf("%p\n", &arr[0]);//int*
	printf("%p\n", &arr[0] + 1);//+4

	printf("%p\n", arr);//int*
	printf("%p\n", arr + 1);//+4
	//&arr[0]和arr都是首元素的地址,+1就是跳过一个元素

	printf("%p\n", &arr);
	printf("%p\n", &arr+1);//+40
	//因为&arr是数组的地址,+1的操作是跳过整个数组的
	return 0;
}

1.sizeof内部单独放一个数组名的时候,数组名表示的就是整个数组,计算的是整个数组的大小单位是字节。
2.&数组名,数组名表示的是整个数组,取出的是整个数组的地址。
除此之外,遇到的所有数组名都是数组首元素的地址。

3.&arr[0]和arr都是首元素的地址,+1就是跳过一个元素

4.因为&arr是数组的地址,+1的操作是跳过整个数组的

四.使用指针访问数组

1.因为数组在内存中是连续存放的。
2.数组名就是首元素的地址(方便找到起始位置)可以使用指针来访问数组。

代码1(正常写法):

int main()
{
	int arr[10] = { 0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int* p = arr;
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		scanf("%d",&arr[i]);
	}
	for (i = 0; i < sz; i++)
	{
		printf("%d",arr[i]);
	}

	return 0;
}

代码2(通过指针解引用把值输出):

scanf("%d", p + i);使用scanf函数从用户接收一个整数,并将其存储在指针p加上i所指向的位置。这实际上是向数组中输入数据。

printf("%d ", *(p + i));使用printf函数输出指针p加上i所指向的整数。这实际上是从数组中读取数据并输出。

int main()
{
	int arr[10] = { 0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int* p = arr;
	//p <==> arr
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		scanf("%d", p + i);
	}
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}

	return 0;
}

代码3

数组加元素的形式,这里使用arr + i来获取数组第i个元素的地址

int main()
{
	int arr[10] = { 0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int* p = arr;
	//p <==> arr
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		scanf("%d", arr + i);
	}
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(arr + i));
	}
	return 0;
}

代码4

在C语言中使用i[arr]时,实际上进行了一个指针偏移操作。

1.首先,arr被解析为指向数组首元素的指针。在内存中,数组的元素是连续存储的,而数组名实际上是一个指向数组首元素的指针。因此,通过arr可以找到数组的起始位置。
2.接下来,使用索引i对指针进行偏移。在C语言中,一个指针偏移n个元素就是移动指针到从起始位置开始的第n个元素。因此,通过偏移i个元素,你可以找到数组中第i个元素的位置。

3.arr[i]中的[]是索引运算符,用于访问数组中的元素。它表示将数组名arr解析为指向数组首元素的指针,并使用索引i进行偏移,以访问数组中第i个元素的值。

int main()
{
	int arr[10] = { 0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int* p = arr;
	//p <==> arr
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		scanf("%d", &p[i]);
	}
	for (i = 0; i < sz; i++)
	{
		printf("%d ", i[arr]);
	}

	return 0;
}

以上代码说明:

arr[i] == *(arr + i) ==*(i+arr) == i[arr],

&p[i] == &arr[i] == p + i == arr + i,
p[i] == *(p + i)

五、一维数组的本质

引子:我们之前都是在函数外部计算数组的元素个数,把数组传给下一个函数后,函数内部可以求数组元素的个数吗?

数组传参的时候形参是不会创建数组的,实际上传的是首元素的地址,发生了数组降级

void test(int arr[])  //int *arr
{
	int sz = sizeof(arr) / sizeof(arr[0]);
	printf("%d\n", sz);//?
}

void Print(int arr[],int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d", arr[i]);
		//arr[i] == *(arr + i)
	}
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);//获取数组中的元素个数

	//test(arr);//这里的数组名就是数组首元素地址
	Print(arr,sz);

	return 0;
}

六、传址调用和传值调用

传值调用:传的是变量,传值调用

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

int main()
{
	int a = 10;
	int b = 20;

	int ret = Add(a, b);
	//调用函数
	printf("%d\n", ret);
	return 0;
}

传值调用:传的是地址

6.1模拟strlen函数
int my_strlen(const char* s)
//const此处保护arr[]中的值,防止被修改
{
	//size_t = unsigned int
	size_t count = 0;
	while (*s != '\0')
	{
		count++;
		s++;
	}
	return count;

	//char* start = s;
	//while (*s != '\0')//  \0的ASCII编码是0
	//{
	//	s++;
	//}
	//return s - start;

}

int main()
{
	//strlen - 求字符串的长度 - 统计的是\0前面出现的字符的个数
	char arr[] = "abcdef";
	int len = my_strlen(arr);//传的是数组首元素的地址
	//数组名是数组首元素的地址

	printf("%zd\n", len);

	return 0;

}
6.2为什么有传址和传值两种调用方式

因为有一些问题是不使用指针无法解决的!!!

传值调用函数时,函数的实参传给形参,形参是实参的一份拷贝
形参有自己独立的空间,对实参的修改不会影响实参!!!

void Swap1(int a, int b)
{
	a = a ^ b;
	b = a ^ b;  //b = a ^ b ^ b = a ^ 0
	a = a ^ b;
}


void Swap2(int *pa, int *pb)
{
	int t = 0;
	t = *pa;
	*pa = *pb;
	*pb = t;
}

int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	//交换a和b的值

	printf("交换前:a = %d b = %d\n", a, b);
	//Swap1(a, b);//传值调用 此处不发生变化
	Swap2(&a, &b);//传址调用

	printf("交换后:a = %d b = %d\n", a, b);
	
	return 0;
}

int main()
{
	int a = 10;
	int* pa = &a;//a和pa有联系
	*pa = 20;
	printf("%d\n", a);

	return 0;
}

你可能感兴趣的:(笔记,c++,c语言,开发语言)