c语言指针详解
c语言指针
- 指针的定义和使用
- 指针大小
- 野指针和空指针
- 万能指针 void*
- const修饰的指针变量
-
- 第一种修饰普通变量
- 第二种修饰指针类型
- 第三种修饰指针变量
- 第四种修饰指针类型修饰指针变量 （常量指针）
- 指针和数组
-
- 指向数组的指针
- 指针运算
- 指针数组
- 多级指针
- 指针和函数
-
- 值传递和地址传递
- 数组作为函数参数
-
- 字符串去空格
- 指针作为函数的返回值
-
- 字符串查找字符串
- 指针和字符串
-
- 栈区字符串和数据区字符串的区别
- 字符串数组
- 字符指针作为函数参数
- 主函数参数
&是取地址符号 是升纬度的
*是取值符号 是降维度的
指针的定义和使用
指针就是内存中的一个地址编号，指针变量用于存储地址，指针变量也是一个变量。
#include内存中的每一个数据都会分配相应的地址
char 占内存一个字节，分配一个地址
int 占内存四个字节，分配四个地址
windows电脑在做数据存储时采用小端对齐（低位数据放在低位内存地址，高位数据放在高位内存地址）。
大端对齐：低位数据放在高位内存地址，高位数据放在低位内存地址。
计算机的字节顺序模式分为大端数据模式和小端数据模式，它们是根据数据在内存中的存储方式来区分的。小端对齐和大端对齐都是计算机中数据存储的一种方式。
数据类型* 变量名
定义指针类型变量
*变量名 = 值通过指针间接修改变量的值
#include结果：
0000004CCAAFF874
0000004CCAAFF874
20
20
指针间接赋值
- 两个变量：普通变量、指针变量
- 建立关系 指针变量=&普通变量
- 通过 *运算符赋值 *指针变量=值
指针大小
int main(void) {
int a = 0;
int* b = &a;
printf("%d\n", sizeof(a));//4
printf("%d\n", sizeof(b));//64位打印的是8,32位打印的是4
return 0;
}
所有的指针类型存储的都是内存地址，内存地址都是一个无符号16进制整型数。
64位操作系统下所有指针类型是8个字节大小,32位操作系统下所有指针类型是4个字节大小。所有的指针类型占的字节大小都一样
int main(void) {
printf("%d\n", sizeof(int*));
printf("%d\n", sizeof(char*));
printf("%d\n", sizeof(short*));
printf("%d\n", sizeof(long*));
printf("%d\n", sizeof(float*));
printf("%d\n", sizeof(double*));
return 0;
}
既然地址是无符号类型的整型数（unsigned int），我们定义一个整型int不行吗？为什么要用int* ？
int main(void) {
int a = 0;
int b = &a;
//*b = 666;//err: b不是指针类型，而是一个整型
*(int*)b = 666;//强制类型转换，把一个普通变量转成int*类型
printf("%d\n", a);//666
return 0;
}
既然char* 占4字节大小，int* 也是占4个字节大小，我可以都用int* 不用char*吗？
#include
野指针和空指针
野指针：指针变量指向一个未知（内存）的空间。
#include 
可以看到报错了：引发了异常: 读取访问权限冲突。为什么？操作系统将0-255作为系统占用不允许读写操作。
程序中允许出现野指针，但是操作野指针对应的内存空间可能报错，有几个问题，1. 这块内存地址允不允许访问；2. 这里有没有数据；3. 这数据能不能修改 。
指针变量也是变量，是变量就可以任意赋值，不要越界即可(32位为4字节，
64位为8字节），但是，任意数值赋值给指针变量没有意义，因为这样的指针
就成了野指针，此指针指向的区域是未知(操作系统不允许操作此指针指向的
内存区域）。所以，野指针不会直接引发错误，操作野指针指向的内存区域才会出问题。在程序运行过程中，我们尽量不要把一个具体的值（或者变量的值）直接赋值给指针变量。
空指针：是指内存地址编号为0的空间。
野指针和有效指针变量保存的都是数值，为了标志此指针变量没有指向任何变量（空闲可用），c语言中，可以把NULL赋值给此指针，这样就标志此针为空指针，没有任何指针。
操作空指针对应的空间一定会报错，空指针可以用作条件判断
int main() {
int* b = NULL;
//*b = 666;//err: 引发了异常: 写入访问权限冲突。
//printf("%d\n", *b);//err: 引发了异常: 读取访问权限冲突。
if ( b == NULL ){
printf("这是空指针");
}
return 0;
}
NULL是一个值为0的宏常量：
#define NULL ((void *)0)
万能指针 void*
void*指针可以指向任意变量的内存空间，万能指针并不是真的万能，而是他能接收任意类型的数据，在通过万能指针修改变量的值时，需要转成变量对应的的指针类型。
万能指针可以直接赋值给其他类型的指针，其他类型指针赋值给万能指针的时候，最好强转一下类型才可以。
可以将所有指针类型赋值给万能指针 ，万能指针一般用作于函数形参。
#include const修饰的指针变量
第一种修饰普通变量
普通的常变量我们通过一级指针修改
#include 可以通过指针修改const定义的常变量，但是不能修改#define定义的宏定义常量。为什么？#define宏仅仅是展开，有多少地方使用，就展开多少次，不会分配内存。（宏定义不分配内存，变量定义分配内存）。const常变量会在内存中分配(可以是堆中也可以是栈中)。
第二种修饰指针类型
#include #include 
const 修饰
指针类型可以修改指针变量的值，不可以修改指针指向内存空间的值。这里的是指针对应的内存空间，指向常量的指针。
const int* c = &a;
c = &b;
PS：我们可以这样记， const 跟 * 近不能修改 * ，跟c近不能修改c，const相当于加锁一样，哪个加上锁哪个就不能修改了。
第三种修饰指针变量
const 修饰
指针变量可以修改指针指向内存空间的值，不可以修改指针变量的值。这里的c是指针变量。
int* const c = &a;
*c = 200;
int main() {
int a = 10;
int b = 20;
int* const c = &a;
//c = &b;//err
*c = 200;//ok
printf("%d\n", a);//200
return 0;
}
第四种修饰指针类型修饰指针变量 （常量指针）
一级指针常变量我们通过二级指针来修改
const修饰指针类型 修饰指针变量
const int* const c = &a; 这里的c是只读指针
通过二级指针可以修改一级指针的值（相当于c），修改一级指针对应内存空间的值（*c）。同理，三级指针可以修改二级指针的值，可以依次往前扣。
#include 
指针和数组
指向数组的指针
- 指针变量 [ 下标 ]
- *(指针变量 + 偏移量)
数组名字是数组的首元素地址，但它是一个常量。
int arr[] = { 1,2,3,4,5 };
printf("%p\n", arr);//0000009C47B4F988
printf("%p\n", &arr[0]);//0000009C47B4F988
#include 指针类型+1 等同于 内存地址+sizeof(类型)，这里面元素并不是以内存地址编号为单位的，单位都是具体类型为单位的。
#include 两指针相减，等到的结果是两个指针的偏移量（步长），所有的指针类型相减都是int类型。
指针+1 相当于 +sizeof(类型)
指针-1 相当于 -sizeof(类型)
指针相减 = 变量值(地址编号)相减/sizeof(类型)
int main() {
int arr1[] = { 1,2,3,4,5 };//int占4个字节
int* p1 = arr1;
printf("%p\n", p1);//00000086013BF8C8
p1++;
printf("%p\n", p1);//00000086013BF8CC
int step = p1 - arr1;//C8-CC=4 ，相当于 4/sizeof(int)=1
printf("步长：%d\n",step);//1
return 0;
}
-
指针跟数组的不同点
- 一个是变量，一个是常量
- 空间占的字节大小不一样
数组作为函数参数会退化为指针，丢失了数组的精度（数组元素个数）
#include 既然退化成指针了，我们可以写成int* arr，他们是等价的
#include 结果：234567
如果我们指针去操作数组元素情况，最好写成数组样式，简单明了，一般情况不写指针样式。
指针运算
指针运算跟指针类型对应的基本类型有关。
指针加减运算
（1）加法运算
- 指针计算并不是简单的整数相加
- 如果是int*，+1的结果是增加一个int的大小
- 如果是char*，+1的结果是增加一个char的大小
#include 举个例子： 字符串拷贝的操作
1.通过数组操作
#include2.指针加减运算
void CopyStr(char* dest, char* ch) {
int i = 0;
while (*(ch + i)) {
*(dest + i) = *(ch + i);//注意一定要加括号，因为优先级别的问题
i++;
}
*(dest + i) = 0;
}
3.把2再简化，还能这样写
void CopyStr(char* dest, char* ch) {
while (*ch) {
*dest = *ch;
dest++;//指针+1 相当于指向数组下一个元素 内存地址变化了sizeof(char)
ch++;
}
*dest = 0;
}
4.上面都还不是指针的最终版本，接下来我们再写个不一样的
void CopyStr(char* dest, char* ch) {
while (*dest++ = *ch++);
}
第一个算dest++、ch++，但其实是最后一个算的；然后是取值*dest、ch，接着给dest赋值；赋值完之后到这里表达式已经计算完成了，虽然++还没加但是表达式已经完成了，赋值完之后作为while循环的条件。
总的来说就是，第一步 取值*dest、*ch，第二步 *dest=*ch，第三步 把这个值作为条件判断，赋值哪个就是哪个进行判断，如果是0，这时候0已经赋值过去给*dest，不满足循环结束循环，最后一步 dest++、ch++。
（2）减法运算
- 跟加法运算差不多
#include指针加减偏移量是允许的；减法可以减指针，但是没有意义，此外还能用 > 、?、&& 等等
#include指针数组
每一个元素都是一个指针，指针数组是一个二维数组模型。
#include 问1： 为什么我把int* arr[3] = {&a,&b,&c};换成char* arr[3] = {&a,&b,&c};
得到的结果是一样的？
87
65
89
指针数组大小：12
指针元素大小：4
答： *是取值， &是取地址，因为两个不同的数组保存的是同一个地址值，所以一样。
指针数组是一个特殊的二维数组模型
#include 指针数组对应于二级指针，最好还是用二维数组吧，比较好看。
puts(char* s)输出更简洁、更方便。而且使用 puts() 函数连换行符 ‘\n’ 都省了，使用 puts() 显示字符串时，系统会自动在其后添加一个换行符。s可以是字符指针变量名、字符数组名，或者直接是一个字符串常量。功能是将字符串输出到屏幕。输出时只有遇到 ‘\0’ 也就是字符串结束标志符才会停止。puts(“”);相当于printf(“\n”);
多级指针
C语言允许有多级指针存在，在实际的程序中一级指针最常用，其次是二级指针。二级指针就是指向一个一级指针变量地址的指针。
#include#include指针和函数
值传递和地址传递
值传递：形参不影响实参的值。
#include地址传递:形参可以改变实参的值。
#include数组作为函数参数
数组名做函数参数，函数的形参会退化成指针丢失精度，因为一级指针二级指针没办法统一，所以是丢失精度。需要传递 元素个数（或叫精度）。
- 用数组样式
#include- 用指针样式
void AddStr(char* target,char* s) {
int i = 0;
for (;*(target+i)!=0;i++) {}
//printf("%d\n", i);//5
//printf("%d\n", strlen(target));//5,相当于strlen(target)
int j = 0;
while (*(s+j)!= 0) {
*(target+i + j) = *(s+j);
j++;
}
//target[i + j] = '\0';//默认是0
}
- 指针++
void AddStr(char* target,char* s) {
while (*target)target++;
while (*s) {
*target = *s;
s++;
target++;
}
}
再优化一下
void AddStr(char* target,char* s) {
while (*target)target++;
while (*target++ = *s++);
}
字符串去空格
#include其实还能优化，思路是找到不是空格就覆盖前面的值。
#include指针作为函数的返回值
#include结果：xy
字符串查找字符串
#include 指针和字符串
栈区字符串和数据区字符串的区别
#include 为什么会报错？原因是因为创建字符串存储的位置是不同的。
char s[] = “hello xy”;存储的是栈区字符串。
char* p = “hello xy”;是数据区下的常量区字符串，指针指向的是字符串常量区的地址。例如printf(“hello xy”);这个字符串没有一个名字去标志字符串所在的位置，所以这个字符串所在的位置就是数据区下的常量区字符串。这个字符串常量区的内容是不允许修改的。
#include 结果：地址一样：00A78B40。因为这两个字符串是完全一致并且不能修改，在内存中做一份就可以了，p1和p2同时指向字符串常量区的地址，并不是p1和p2不能修改，而是"hello xy"对应的区域中的数据不能修改，他们地址相同而且都不允许修改，他们是只读的，多个指针指向同一地址是可以的。
字符串数组
#include 区别：arr1里面的字符串可以修改，arr2的字符串（是常量字符串，把地址放到了arr2里）不能修改。
字符指针作为函数参数
#include getstr_length 和 getstr_length2两个都行，如果不希望改变参数里面的内容可以写成getstr_length2(const char* ch)
主函数参数
我们平常主函数都是 main(void) 或者干脆什么都不写 main()，但是 正常情况下主函数是有两个参数的。我们程序在运行起来是通过主函数开始执行，可以对主函数进行传参的操作，我们cmd运行程序后面有时候会带一些参数，我们可以自己去捕获一下。
假设命令是 gcc -o main main.c
==> 4个参数
intargc表示传递参数的个数
char*argv[] = { “gcc” , “-o” ,“main” ,“main.c” } 表示参数具体内容
#include 这个代码我们需要单独去外边（cmd）运行一下
gcc -o main.exe main.c -std=c99
D:\cCode\VSstudyCYuYan\day08\main.exe 空格之后随便输字符串
-std=c99 c99库，因为我在循环内部定义参数应该使用c99编辑器，
for (int i = 0;
可以看到输出了D:\cCode\VSstudyCYuYan\day08\main.exe，这个是我们的运行程序，运行程序也算作参数的一个，它自己能把自己捕获到，算作字符串中的第一个。我输入的命令是6个字符串。
我们还可以加个判断，如果缺少参数我们就不给他运行下去
#include 
argv[]不是在其他程序调用传递的，而是在执行应用程序的时候传递的。很多程序会有这个内容，但是用不到它，写起来也麻烦，有时候我们就不写。如果你想传递参数的情况下，用这两个参数去传递去接收。比如你要想编译程序的情况下，你就知道哪个是源程序哪个是其他程序。