#C语言指针个人总结#

一.内存和地址

1内存

内存就是一片空间，用来存放东西的地方，那么对与计算机来讲，肯定是存放各种数据和程序的地方。计算机上CPU（中央处器）在处理数据的时候，需要的数据是通过数据总线在内存中读取的，处理后的数据也会通过数据总线放回内存中,但是CPU是怎么知道要进行数据的存入和读出，并且准确无误地找到数据要存放和读出的地方，这里就要引出地址的概念了。

2地址

内存是一片很大的空间，把内存划分为⼀个个的内存单元，每个内存单元的大小取1个字节，这样可以更好地管理数据。然后给每一个内存单元都分配一个编号，可以通过这个编号找到对应的内存单元，也就是地址。而C语言中，我们可以这样理解，内存单元的编号 = 地址= 指针

计算机中常⻅的单位（补充）：
⼀个⽐特位可以存储⼀个2进制的位1或者0
1Byte = 8bit（比特位）
1KB = 1024Byte（字节）
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
1PB = 1024TB

二.指针

1.操作符(&)-取地址操作符

#include <stdio.h>
int main()
{
	int p=2;
	printf("%p",&p);
	return 0;
}

&a取出的是a所占4个字节中地址较小的字节的地址。

比如，虽然整型变量占用4个字节，我们只要知道了第⼀个字节地址，计算机系统顺藤摸瓜便可访问到4个字节的数据也是可行的。

（32位机器的寻址空间是2^32, 即32个bit，也就是4个字节。同理64位编译器-寻址空间为八个字节。）

1、1个字节(Byte) 为8位二进制

2、Int类型 占用4个字节

3、long类型 占用8个字节

4、float类型占用4个字节
5、double类型占用8个字节

2.解引用符（*）

我们放了一个东西在一个内存空间内，那我们现在就可以通过地址去访问。

此时就用到了，解引用符（*）。

int m=2;
int* p = &m;   调用时函数传参传&num
"%d", *p;      *p相当于成为p的整型数值
"%p", p;       p相当于&p为p的地址

下面我们看具体的代码实现

#include <stdio.h>
int main()
{
	int p=2;
	int *x=&p;
	printf("%d\n",*x);
	printf("%p\n",x);
	return 0;
}

三.数组指针与指针数组

1数组指针：数组指针是指向数组的指针，存放的是数组的地址。（常用于二维数组的使用）

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

		}
		printf("\n");
	return 0;
}

对于这个(*p)[3]这个(*p)是指针数组，[3]是其中的数组长度，(*p)[3]将数组类型转换为(*p)

对于*(*(p+i)+j))或者*(p[i]+j)

1. *(*(p+i))+j
这个表达式首先通过 p+i 计算出数组中的一个元素的地址，然后使用 (*) 解引用这个地址得到该位置的值，再对这个值进行解引用操作 (*) ，最后加上 j 。它实际上先访问了数组的一个元素，再对该元素进行操作。

2. *(p[i]+j)
这个表达式直接计算p[i]+j，将数组下标 i 和 j 相加得到一个新的偏移量，然后用这个偏移量去数组 p 中查找元素并取值。这里没有两次解引用，一次解引用就完成了对指定位置元素的操作。
总结区别：
- 优先级不同：*(*(p+i)) 中两个 * 运算符的优先级高于 + ，所以会先解引用两次；而 *(p[i]+j) 的 + 先于 * 执行。
- 内部顺序不同：第一个表达式先解引用 p+i 指向的内存，再解引用那个值，第二个表达式则是直接访问 p 中 i 和 j 组合后的索引位置。

p是二维数组第一行的地址；

p+i是二维数组第i行的地址；

*(p+i)是二维数组第i行元素组成的一维数组的数组名，也是第i行这个一维数组的首元素地址；

*(p+i)+j就是第i行第j列元素的地址。

*p相当于第一行元素组成的数组的数组名arr[0]，*(*(p+0)+0)只不过将0省略了，也是这个数组arr[0]首元素的地址，即arr[0][0]的地址。

2指针数组：指针数组是存储指针的数组。（用于一维数组较为方便）

我们使用的是一个新的pa地址变量来取arr的首地址，但是arr本身就可以是首地址。

有如下表达形式：

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

3.简单应用

1.使用函数传参

#include <stdio.h>
void s(int* p);//函数原型
int main()
{
	int p = 2;
	printf("%p\n", &p);
	s(&p);
	return 0;
}
void s(int* p)//传入的应该是指针P----&p
{
	printf("%p\n", p);    //p==&p
	printf("%d\n", *p);   //*p的数据类型为int
}

2.使用指针输出数组并且求和

#include <stdio.h>
int main()
{
	int* p;
	int arr[] = { 1,2,3,4,5 };
	p = arr;
	int x = 0;
	//for (p; p<arr + 5; p++)
	//{
	//	printf_s("%d", *p);
	//}
	while (p < arr + 5)
	{
		x += *p;
		printf("%d\n", *p);
		p++;
	}
	printf("%d", x);
	return 0;
}

3.将数组两个特定的数中间的数放前面去

#include <stdio.h>
void move(int arr[], int n, int m);
int main()
{
	int arr[] = { 1,2,3,4,5 };
	move(arr, 5, 2);
	int q;
	for (q = 0; q < 5; q++)
	{
		printf("%d", *(arr + q));
	}
	return 0;
}
void move(int arr[], int n, int m)
{
	int a;
	int t, i;
	for (a = 0; a < m; a++)
	{
		t = *(arr + n - 2);
		for (i = n - 1; i > 0; i--)//arr[1+n-2]=arr[1+n-3] arr[1+n-3]=arr[1+n-4]	//arr[]={1,2,3,4,5,6}  6 2	//n为个数，m为后面多少个数																					
		{
			*(arr + i - 1) = *(arr + i - 2);
		}
		*arr = t;
	}
}

4.求一个字符数组的长度

#include <stdio.h>
#include <string.h>
int en(char* c);
int main()
{
	char c[] = { 'a','b','c','d','\0' };

	int lenn = strlen(c);
	printf("%d\n", en(c));//使用指针遍历
	printf("%d\n", lenn);//使用strlen
	return 0;
}
int en(char* c)
{
	int len = 0;
	while (*c != '\0')
	{
		len++;
		*c++;
	}
	return len;
}

5.使用指针比大小

#include <stdio.h>
int en(int* p, int* q);
int main()
{
	int p = 3;
	int q = 4;
	if (p != q)
	{
		printf("%d", en(&p, &q));
	}
	else
		printf("一样大");
	return 0;
}
int en(int* p, int* q)
{
	if (*p > *q)
	{
		return *p;
	}
	else
		return *q;
}

5.求数组中的最大值

#include <stdio.h>
int main()
{
	int arr[] = { 2,3,4,5,43,55,7,45 }, * p, max;
	p = arr;
	max = *p;
	p++;
	while (p < arr + 8)
	{
		if (*p > max)
		{
			max = *p;
			p++;
		}
		else
			max = max;
			p++;
	}
	printf("%d", max);
	return 0;
}

四. const关键字

1.const介绍

C语言中提供了const关键字，const 中文意思是“恒定的”，从字面意思不难理解，它可以使其修饰的对象变得“恒定”，也就是不能改变。当开发者有意无意地改变被const修饰的对象时，编译器就会报错，使得代码的问题在编译阶段就能被发现，从而提高了开发的效率。

2.const修饰局部变量

int const n = 1;
const int n = 1;

3.const修饰指针变量

在const修饰局部变量时，变量将变得不可修改。但如果绕过变量，使用局部变量的地址，就可以修改掉局部变量的值，这显然不符合我们的需求，所以想要使变量的值无法通过指针改变时，可以使用const修饰指针变量。它又分为一下几种情况：

int a = 1;
int b = 1;
int c = 1;
//const 在*的左边
int const* p1 = &a;
//const 在*的右边
int* const p2 = &b;
//const 在*的两侧都有
int const* const p3 = &c;

• 当const在*左边时，不能通过解引用指针变量来修改指针所指向的变量。
• const在*右边时，不能改变指针变量内存储的地址。
• const在*两侧都有时，既不能通过解引用指针变量来修改所指向的变量，也不能改变指针变量所指向的地址。
• 所以，如果我们想要一个局部变量彻底的无法被修改，需要在定义时使用const修饰变量，同时使用const在*左边修饰指向这个变量的指针变量。

代码实现

//const 的学习
//1 const修饰的
#include <stdio.h>
int main()
{
	const int p = 9;
	const int* pa = &p;
	printf("%d\n", *pa);//									const int (里面放什么什么不能修改)=（）;
	int q = 8;				//	const int q=1;///          *p无法修改可以改变p地址的值来间接改变*p
	pa = &q;				//	*pa=&q
	printf("%d\n", *pa);	//	printf("%d",*q);
	return 0;									
}
//2被const 修饰的
#include <stdio.h>
int main()
{
	int a = 9;
	int* const pa = &a;//										这种情况不能改地址&a只能改指向的&a的a的数值
	a = 8;
	printf("%d", *pa);
	return 0;
}
//3
const int* const pa = &a;

有不正确的地方欢迎各路大佬指出。

-----点个关注不迷路-------