一. 内存和地址
比如，我们的内存就相当⼀栋宿舍楼，楼里有很多的房间，每个房间都有一个房间号，每个房间里都住着8个人。这时如果你的朋友想要来找你，我们只需要把房间号告诉他就能快速的找到我们。
然而，，在计算机中每个房间就相当一个内存单元，每个内存单元都有一个编号，每个编号对应着一个房间号，房间里的8个人对应着8个比特位。
- 1Byte = 8bit
- 1KB = 1024Byte
- 1MB = 1024KB
- 1GB = 1024MB
- 1TB = 1024GB
- 1PB = 1024TB
然而，在生活中我们把房间号叫地址，在计算机中我们把内存单元的编号也称为地址。在C语言中我们给地址起了新的名字叫：指针
所以我们可以理解为： 内存单元的编号 == 地址 == 指针
二. 指针变量和地址
1.取地址操作符（&）
在C语言中，如果我们想要的到地址就需要用到取地址操作符（&）
#include<stdio.h>
int main()
{
int a = 10;
printf("%p\n", &a);
return 0;
}在x86环境下
2. 指针变量和解引用操作符（*）
这时，我们已经将a的地址取出来了，我们肯定要将地址存储起来，方便以后的使用，那么我们该如何存储地址呢？这就需要用到指针变量了。
1.指针变量
#include<stdio.h>
int main()
{
int a = 10;
int* pa = &a;
return 0;
}2.指针类型
- int* pa = &a;
- *是指pa为指针变量
- int是指pa指向的对象为int类型
3.解引用操作符 (*)
既然，我们已经将地址存储起来了，那么我们该如何使用他呢？这时就要用到解引用操作符(*)了。
#include<stdio.h>
int main()
{
int a = 10;
int* pa = &a;
printf("%d\n", *pa);
return 0;
}还是，这段代码如果我们想用指针变量打印a的值我们就可以用*pa来解决。
#include<stdio.h>
int main()
{
int a = 10;
int* pa = &a;
*pa = 20;
printf("%d\n", a);
return 0;
}同时，如果我们想要改变a的值，我们只需要给*p重新赋值即可。
3.指针变量的大小
我们可以通过代码来了解一下指针变量的大小。
#include<stdio.h>
int main()
{
printf("%zd\n", sizeof(int*));
printf("%zd\n", sizeof(char*));
printf("%zd\n", sizeof(float*));
printf("%zd\n", sizeof(double*));
printf("%zd\n", sizeof(long*));
printf("%zd\n", sizeof(short*));
printf("%zd\n", sizeof(long long*));
return 0;
}在x86环境下
在x64环境下
我们可以看到在x86环境下所有类型指针变量的大小都是4个字节，x64下为8个字节。所以我们可以得出结论。
- 32位平台下地址是32个bit位，指针变量大小是4个字节（x86)
- 64位平台下地址是64个bit位，指针变量大小是8个字节 (x64)
- 注意指针变量的大小和类型是无关的，只要指针类型的变量，在相同的平台下，大小都是相同的
那么在相同平台下，大小都相同，那指针变量类型有什么意义呢？
三.指针变量类型的意义
1.指针的解引用
#include<stdio.h>
int main()
{
int a = 0x11223344;
int* pa = &a;
*pa = 0;
return 0;
}在int*类型下，将*pa赋值为0，会将四个值都赋为0
在char*类型下，将*pc赋值为0，只会将第一个赋值为0
结论：指针的类型决定了，对指针解引用的时候有多大的权限（一次能操作几个字节）。
下面这些时不同的类型，在不同环境下的字节大小
2.指针+-整数
#include <stdio.h>
int main()
{
int n = 10;
int* pi = &n;
char* pc =&n;
printf("&n =%p\n", &n);
printf("*pi =%p\n", pi);
printf("*pi+1=%p\n", pi + 1);
printf("*pc =%p\n", pc);
printf("*pc+1=%p\n", pc + 1);
return 0;
}
我们可以看出， char* 类型的指针变量+1跳过1个字节， int* 类型的指针变量+1跳过了4个字节
指针+1，其实跳过1个指针指向的元素。
3.void* 指针
在指针类型中有⼀种特殊的类型是 void * 类型的，可以理解为无具体类型的指针或者叫泛型指 针），这种类型的指针可以用来接受任意类型地址。但是也有局限性，void* 类型的指针不能直接进行指针的+-整数和解引用的运算。
例如，如果我们用void* pa存放a的地址，我们发现如果我们要改变a的值，是无法改变的，因为我们并不知道要存放几个字节，同时我们也无法进行指针的运算，因为我们也不知道要跳过几个字节。
四.const
1.const修饰变量
const的作用其实是使变量不能被修改。
我们可以看下面这段代码。
我们可以发现当我们想改变a的值时，我们发现a不许需被修改了，这就是const的作用。
const既然能修饰变量，那么是不是也能修饰指针变量呢，答案是可以的。
2.const修饰指针变量
一般来讲const修饰指针变量，有两种形式，可以放在*的左边，也可以放在*的右边，但两者之间的意义是不⼀样的。
1.const 放在*的左边做修饰
形式:
const int * pa
或者
int const * pa
如果我们想要改变*pa 和pa的值。
我们可以看到当我们想要改变* pa的值时，我们是不被允许的，但是改变pa的值是被允许的。
2.const 放在*的右边做修饰
形式
int * const pa
如果我们想要改变*pa 和pa的值。
我们会发现这时*pa被允许，pa不被允许了。
其实const还有第三种修饰方式，放在左右两边。
3.const 放在左右两边做修饰
形式：
const int * const pa
这时，如果我们想要改变*pa 和pa的值。
我们发现*pa和pa都不被允许改变了。
4.结论
- 结论：const修饰指针变量的时候
- const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。 但是指针变量本身的内容可变。
- const如果放在*的右边，修饰的是指针变量本身，保证了指针变量的内容不能修改，但是指针指 向的内容，可以通过指针改变。
- const如果放在左右两边，修饰的是指针指向的内容和指针变量本身，保证了指针指向的内容和指针变量的内容不能被修改。
五.指针运算
指针的基本运算有三种：
- 指针+- 整数
- 指针-指针
- 指针的关系运算
1.指针+- 整数
我们可以举个例子
#include <stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = &arr[0];
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
for (i = 0; i < sz; i++)
{
printf("%d ", *(p + i));//p+i 这⾥就是指针+整数
}
return 0;
}2. 指针-指针
我们将首地址传给指针变量p,如果指针解引用的值不等于/0，就让p++，直到找到\0的地址，指针就会停在\0的地址处，让p-s(起始地址）就是元素的个数
//指针-指针
#include <stdio.h>
int my_strlen(char* s)
{
char* p = s;
while (*p != '\0')
p++;
return p - s;
}
int main()
{
printf("%d\n", my_strlen("abc"));
return 0;
}3.指针的关系运算
将数组的首地址赋给p,让p<arr+sz,每循环一次p++,让p往下走，打印数组里的值。
//指针的关系运算
#include <stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = &arr[0];
int sz = sizeof(arr) / sizeof(arr[0]);
while (p < arr + sz) //指针的⼤⼩⽐较
{
printf("%d ", *p);
p++;
}
return 0;
}六.野指针
野指针的形成
1.指针未初始化
#include <stdio.h>
int main()
{
int* p;//局部变量指针未初始化，默认为随机值
*p = 20;
return 0;
}2.指针越界访问
#include <stdio.h>
int main()
{
int arr[10] = { 0 };
int* p = &arr[0];
int i = 0;
for (i = 0; i <= 11; i++)
{
//当指针指向的范围超出数组arr的范围时，p就是野指针
*(p++) = i;
}
return 0;
}3.指针指向的空间释放
在这段代码中，test()函数中，将&n返回后，虽然我们将地址成功返回，但是再返回后n所申请的内存空间会被销毁，空间的到释放后，我们虽然能根据地址找到但是没有访问权限。
#include <stdio.h>
int* test()
{
int n = 100;
return &n;
}
int main()
{
int* p = test();
printf("%d\n", *p);
return 0;
}七.传值调用和传址调用
1.传值调用
这段代码就是经典的传值调用
#include<stdio.h>
int Add(int x, int y)
{
return x + y;
}
int main()
{
int a, b;
scanf("%d %d", &a, &b);
int r = Add(a, b);
printf("%d\n", r);
}
然而我们看看下一段代码
#include <stdio.h>
void Swap1(int x, int y)
{
int tmp = x;
x = y;
y = tmp;
}
int main()
{
int a = 0;
int b = 0;
scanf("%d %d", &a, &b);
printf("交换前：a=%d b=%d\n", a, b);
Swap1(a, b);
printf("交换后：a=%d b=%d\n", a, b);
return 0;
}
我们发现a和b的值并没有发生交换。这时我们可以试试另外一种方法。
2.传址调用
#include <stdio.h>
void Swap2(int* px, int* py)
{
int tmp = 0;
tmp = *px;
*px = *py;
*py = tmp;
}
int main()
{
int a = 0;
int b = 0;
scanf("%d %d", &a, &b);
printf("交换前：a=%d b=%d\n", a, b);
Swap2(&a, &b);
printf("交换后：a=%d b=%d\n", a, b);
return 0;
} 
我们发现这时我们成功交换了a和b的值。那为什么第一种方法不行呢？
这是因为实参传递给形参的时候，形参会单独创建一份临时空间来接收实参，对形参的修改不影响实参
第二种方法，我们是直接将地址传过去，让他们直接调用地址，通过解引用来改变值，从而达到交换的目的。
好了今天的分享就到这里吧，我们下一篇见。
标签：const,变量,int,C语言,pa,printf,指针 From： https://blog.csdn.net/zm3rttqs9f/article/details/140780909