指针（1）-学习笔记
- 1.内存
- 1.1内存
- 2.指针变量和地址
- 2.1取地址操作符（&）
- 2.2指针变量和解引用操作符（*）
- 2.2.1 指针变量
- 2.2.2解引用操作符
- 3 指针变量类型的意义
- 3.1指针的解引用
- 3.2指针+-整数
- 3.3 void*指针
- 4.const修饰指针
- 4.1 const修饰变量
- 5.指针运算
- 5.1 指针+-整数
- 5.2 指针-指针
- 5.3 指针的关系运算
1.内存
1.1内存
内存就像一个房间号，有了房间号，就可以快速的找到，就可以提高效率。我们知道CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后的数据也会放回内存中，其实就是把内存划分为一个个的内存单元，每个内存单元的大小取1个字节
计算机常见的单位：
bit - 比特位
Byte - 字节
KB
MB
GB
TB
PB
单位换算：
1Byte = 8bit
1KB = 1024Byte
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
1PB = 1024TB
其中，每个内存单元，相当于一个学生宿舍一个字节空间里面能放8个比特位，就相当于，一个宿舍有八个人，每个人是一个比特位。
每个内存单元也都有⼀个编号（这个编号就相当于宿舍房间的⻔牌号），有了这个内存单元的编号，CPU就可以快速找到⼀个内存空间。
在计算机中把内存单元的编号叫做地址，C语言中给地址起了一个新名字指针
所以我们可以理解为内存单元的编号== 地址==指针
2.指针变量和地址
变量创建的本质是什么？
是向内存申请空间
int a=10，是向内存申请4个字节的空间，因为int类型在内存中占四个空间。
2.1取地址操作符（&）
我们可以写一段代码来观察一下地址：
在VS中逐句运行开始后，才可以打开观察内存的页面。
#include<stdio.h>
int main()
{
int a = 10;
printf("%p\n",&a);//&--取地址操作符
return 0;
}
比如，上述的代码就是创建了整型a，内存中申请4个字节，用于存放整数10，其中每个字节都是有地址的，上图4个字节的地址分别是：
0x0069FEA0
0x0069FEA1
0x0069FEA2
0x0069FEA3
&a取出的是a所占4个字节中地址较小字节的地址。虽然整型变量占用4个字节，我们只要知道了第一个字节地址，顺藤摸瓜访问到4个字节的数据也是可⾏的。
2.2指针变量和解引用操作符（*）
2.2.1 指针变量
我们通过取地址操作符（&）拿到的地址是一个数值，这个数值有时候也是需要存储起来，方便后期再使用，我们就把这个存放在：指针变量中。将数值的地址存放在指针变量中。比如：
int main()
{
int n = 20;
int* pn = &n;
return 0;
}
在这里int*是指针变量的类型。pn就被称为指针变量
int n=20;类型是 int
char ch=‘w’;类型是char
int * pn=&n;类型是int *
指针变量是指向了一个变量，比如，上面的代码pn（指针变量）就执行了n（变量）。int中的说明pn是指针变量，int说明pn指向的对象（就是n）是int类型。
2.2.2解引用操作符
在C语言中，我们只要拿到了地址（指针），就可以通过地址（指针）找到地址（指针）指向的对象，这里就必须来了解一下*（解引用操作符）。
int main()
{
int n = 20;
int* pn = &n;
//解引用操作符-间接访问操作符
*pn = 30;//*pn就是n
printf("%d", *pn);
return 0;
}
这里可以看到n的20被改为了30
这里是把n的修改交给了pn来操作，这样对n的修改，就多了一种途径，写代码就会更加灵活。
指针变量的大小和类型是无关的，只要指针类型的变量，在相同的平台下，大小都是相同的。
3 指针变量类型的意义
3.1指针的解引用
指针可以接收与自己不同类型的地址
对比，下面两段代码，观察内存的变化。
代码一：
int main()
{
int n = 0x11223344;
int* pi = &n;
*pi = 0;
return 0;
}
代码二：
int main()
{
int n = 0x11223344;
char* pc = (char*)&n;//强制转换类型
*pc = 0;
return 0;
}
在第二段代码中，强制将n的地址从int类型转换到char类型，可以发现，存储在内存中的字节发生了改变，从4个字节变为1个字节。
结论：指针的类型决定了，对指针解引用的时候有多大的权限（一次能操作几个字节）。
比如：char的指针解引用就只能访问一个字节，而int的指针的解引用就能访问四个字节。
3.2指针±整数
观察下面一段代码：
int main()
{
int n = 10;
char* pc = (char*)&n;
int* pi = &n;
printf("%p\n", pc);
printf("%p\n", pc + 1);
printf("%p\n", pi);
printf("%p\n", pi + 1);
return 0;
}
代码运行结果如下：
我们可以看出，char类型的指针变量+1跳过1个字节，int类型的指针变量+1跳过了4个字节。这就是指针变量的类型差异带来的变化。指针+1，其实跳过1个指针指向的元素。指针可以+1，那么也可以-1.
结论：指针的类型决定了指针向前或者向后走一步有多大（距离）。
3.3 void*指针
void* 是无具体类型的指针（或者叫泛型指针），这种类型的指针可以用来接受任意类型地址。但是也有局限性，void类型的指针不能直接进行指针±整数和解引用的运算。
在3.1中说：指针可以接收与自己不同类型的地址，是对的，但是会编译器会报警告，所以这时候就可以使用void来接收不同类型的地址。
void*的局限性：
当我们试图改变void类型下的数值，就会报错，所以这里我们就可以看到，void类型的指针可以接受不同类型的地址，但是无法直接进行指针计算。
4.const修饰指针
4.1 const修饰变量
const是常属性-被const修饰后就具有常属性，不能被修改。
1.const修饰普通变量
2.const修饰指针变量
变量是可以修改的，如果把变量的地址交给一个指针变量，通过指针变量的也可以修改这个变量。
当const修饰了num后，再改变，编译器提示报错；再C语言中，这里的num是常变量，num的本质还是变量，因为有const修饰，编译器在语法上不允许修改这个变量。
接下来，我们看一段代码：
int main()
{
const int num = 0;
int* pn = #
*pn = 20;
printf("%d", num);
return 0;
}
结果是：20.
我们绕过num，使用num的地址，去修改num，这样结果是可以的。但是，这是不合理的，我们本来的想法就是希望num不要被修改，接下来应该怎么做呢？那我们可以对pn也做一个修饰，也就是const修饰指针。
const修饰指针可以分为三种情况：
① const放在的左边
②const放在的右边
③const同时放在*两边
第一种：
int main()
{
const int num = 10;
int n = 100;
const int* p = #
p = &n;//没有错误
*p = 20;//发生错误
}
意思：表示指针指向的内容，不能通过指针来改变了。但是指针变量本身的值是可以改的，p是可以改的。
第二种：
int main()
{
const int num = 10;
int n = 100;
int* const p = #
p = &n;//错误
*p = 20;//没有错误
}
意思：表示指针变量p本身不可以修改了，但是指针指向的内容，是可以通过指针变量来改变的。
第三种：
int main()
{
const int num = 10;
int n = 100;
const int* const p = #
p = &n;//错误
*p = 20;//错误
}
意思：指针变量p不能被修改，指针变量p指向的内容也不能被修改。
5.指针运算
指针的基本运算有三种，分别是：
①指针±整数
②指针-指针
③指针的关系运算
5.1 指针±整数
因为数组在内存中是连续存放的，只要知道第一个元素的地址，顺藤摸瓜就能找到后面的所有元素。
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 这里就是指针+整数
}
printf("\n");
for (i = sz-1; i >= 0; i--)//倒叙
{
printf("%d ", *(p + i));
}
return 0;
}
也可以用下面的形式来写：
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);
p++;//p=p+1,p是int类型，一次跳过4个字节
}
return 0;
}
上面代码的弊端就是p一直在变化。
5.2 指针-指针
指针-指针后得到的绝对值是指针和指针之间的元素个数。
这种运算的前提条件是：两个指针指向同一块空间
下面的代码就是错误的。
int main()
{//第一个就是好不确定两个数组是不是连续的。
//第二是不知道是按照char类型来算还是int类型来算
char arr1[10];
int arr2[10];
&arr2[8] - arr2[5];//错误的
return 0;
}
注释：
sizeof的返回值是size_t；头文件是#include<string.h>,strlen统计的是字符串中“\0”之前的字符的个数
我们现在可以来自己实现以下计算字符串的长度，不使用strlen
#include<string.h>
size_t my_strlen(char* s)
//传过来的是地址，我们也应该用地址来接受，所以就是指针
//要统计字符串的长度，现在就要看s指向的内容如果不等于\0,就++
{
size_t count = 0;
while (*s != '\0')
{
count++;
s++;
}
return count;
}
int main()
{
char arr[] = "abcdef";
//数值名其实是数组首元素地址
size_t len = my_strlen(arr);//arr==arr[0]
printf("%d", len);
return 0;
}
另一种方法：指针-指针得到的是指针和指针之间的元素个数。
size_t my_strlen(char* s)
{
char* start = s;//将s的起始地址给start
while (*s != '\0')//找到\0之前的地址
{
s++;
}
return s - start;
}
5.3 指针的关系运算
其实就是两个地址比较大小。
使用数组的关系运算来打印数组的内容
我们可以拿出来数组中最后一个元素的地址，然后让p取遍历，如果小于最后一个元素的地址，那么就++
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]);
while (p < &arr[sz])
{
printf("%d ", *p);
p++;
}
return 0;
}
