本文详细解释了C语言中的地址、内存单元、指针及其操作，包括取地址操作符和解引用操作，以及const修饰符对指针的影响。还讨论了野指针、空指针和传递参数的方式（传值与传址），以及如何使用assert进行错误检查。
在C语言中地址就是存在指针变量当中，指针就是存地址的变量
内存与地址
我们知道计算机上CPU在处理数据时，需要的数据是在内存中读取的，处理之后的数据也会放回内存中，内存中会划分为一个个的内存单元，每个内存单元的大小取1个字节。8个比特位（bite）
这样来看，就像我们想要找到宿舍楼中的朋友，就要找到朋友对应宿舍的门牌号。
首先我们要明白每个内存单元相当于一个学生宿舍，一个字节空间里面能放8个比特位，就相当于一个宿舍住8个人。每个内存单元也有一个编号有了这个内存单元的编号，CPU就可以快速地找到一个内存空间，这个编号就相当于每个宿舍的门牌号，方便我们快速找到朋友所在宿舍。在计算机中我们把内存单元的编号称为地址，C语言中叫：指针
内存单元的编号==地址==指针
取地址操作符（&）与解引用操作符（*）
取地址操作符（&）
我们知道C语言中，创建变量其实就是向内存申请空间，&（取地址操作符）这个操作符可以让们得到这个空间的地址，取出的地址是我们申请的空间中地址较小字节的地址（也就是第一个字节的地址）。
我们通过&得到一个地址的数值，这个地址有时候也是需要存储起来方便我蒙后期使用，而存放地址值的变量就是指针变量
int main()
{
int a = 0;
int * pa= &a;//取出a的地址并存储到指针变量pa中
return 0 ;
}指针变量就是来存放地址的，存放在指针变量中的值会理解为指针。
pa左边写的是int*,*是在说明pa是指针变量，而前面的int是在说明pa指向的是整形类型的对象。
我们拿到指针，就可以通过指针去找到指针指向的对象。
取地址操作符&，可以取出一个变量或者常量的地址
解引用操作符*，用来取出指针中存放的值
int main()
{
int a = 0;
int * pa= &a;//取出a的地址并存储到指针变量pa中
*pa=10;//通过pa中存放的地址，找到指向的空间，就是变量a，将变量a改为10
return 0 ;
}指针变量的大小取决于地址的大小
int main() //32位环境 64位环境
{ //X86 X64
printf("%zd\n", sizeof(char *)); //4 8
printf("%zd\n", sizeof(short *)); //4 8
printf("%zd\n", sizeof(int *)); //4 8
printf("%zd\n", sizeof(double*)); //4 8
printf("%zd\n", sizeof(float *)); //4 8
return 0;
}所以指针变量的大小和类型是无关的，只要指针类型的变量在相同平台下，大小都是相同的
指针的解引用
指针类型决定了指针进行解引用操作符的时候访问几个字节，也就是说决定指针的权限。
int main()
{
int n = 0x11223344;
int* pi = &n;
*pi = 0;
printf("%0x", n);//输出结果：0
return 0;
}
int main()
{
int n = 0x11223344;
char* pi = &n;
*pi = 0;
printf("%0x", n);//输出结果：11223300
return 0;
}所以我们看到char*的指针解引用就只能访问一个字节，int*的指针解引用可以访问4个字节。
void*(泛型指针)
char*指向字符的指针
int * 指向整型的指针
short*指向短整型的指针
float*指向单精度浮点数的指针
double*指向双精度浮点数的指针
void*是无具体类型的指针（泛型指针）
这种类型的指针可以用来接收任意类型地址，但是void*类型的指针不能直接进行指针的+ - 整数和解引用运算，因为void*未知大小
一般void*类型的指针是使用在函数参数部分，用来接收不同类型数据的地址，这样的设计可以实现泛型编程的效果，使得一个函数来处理多种类型的数据
const修饰指针
const修饰变量
变量是可以修改的，当这个变量加上const，就不能被修改了。
int main()
{
int m = 0;
m = 20;//此时m是可以被修改的
const int n = 0;
n = 20;//此时n是不可以被修改的，会报错
return 0;
}
n具有了常属性，虽然n不能被修改，但n依旧是变量。在c++中const修饰的变量就是常量
但是如果把变量的地址交给一个指针变量，通过指针变量也还是可以修改这个变量。
const修饰指针变量
void test1()
{
int n = 10;
int m = 20;
int* p = &n;
*p = 20;
p = &m;
}
void test2()
{
int n = 10;
int m = 20;
const int* p = &n;
*p = 20;
p = &m;
}
void test3()
{
int n = 10;
int m = 20;
int* const p = &n;
*p = 20;
p = &m;
}
void test4()
{
int n = 10;
int m = 20;
const int* const p = &n;
*p = 20;
p = &m;
}
int main()
{
test1();//无const
test2();//const放在*左边
test3();//const放在*右边
test4();//*左右两边都有const
return 0;
} 
const修饰指针变量的时候，放在*的左边，const限制的是指针指向的内容，保证了指针指向的内容不能通过指针来改变。但是指针变量本身的内容改变，可以指向其他变量
const修饰指针变量的时候，放在*的右边，const限制的是指针变量本身。保证了指针变量不能在指向其他变量，但可以通过指针变量，修改指针变量指向的内容。
指针运算
指针 + - 整数
指针+指针
int main()
{
int a = 10;
int* pa = &a;
char* pc = &a;
printf("pa = %p\n", pa); //pa = 0113FC68
printf("pa+1 = %p\n", pa+1); //pa+1 = 0113FC6C
printf("pc = %p\n", pc); //pc = 0113FC68
printf("pc+1 = %p\n", pc+1); //pc+1 = 0113FC69
return 0;
}
指针的类型决定了指针进行+1，-1的时候，向前或者向后跳过多大一步
char* 类型的指针变量+1，跳过一个字节，int* 类型的指针变量+1，跳过四个字节。
type * p;
p+1——>会跳过 *sizeof(type)
p+n——>会跳过n*sizeof(type)打印数组
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]);
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d", *(p+i));//p+i就是指针+整数
}
return 0;
}指针-指针
指针-指针计算的前提条件一定是：两个指针指向了同一块空间
指针1 + 整数 == 指针2
指针2 - 指针1 == 整数
（指针-指针）的绝对值==整数(两个指针之间元素个数)
int main()
{
int arr[10] = { 0 };
printf("%d", &arr[9] - &arr[0]);//9
return 0;
}
int main()
{
int arr[10] = { 0 };
printf("%d", &arr[0] - &arr[9]);//-9
return 0;
}计算字符串长度
//my_strlen计算的是字符字符串中\0之前的字符个数
int my_strlen1(const char* str)
{
int count = 0;
while (*str != '\0')
{
count++;
str++;
}
return count;
}
方法二
int my_strlen2(const char* str)
{
char* start = str;
while (*str != '\0')
{
str++;
}
return str - start;
}
int main()
{
char arr[] = "abcdefg";
int len = my_strlen1(arr);//数组名就是数组首元素的地址
printf("%d", len);
int len = my_strlen2(arr);//数组名就是数组首元素的地址
printf("%d", len);
return 0;
} 指针的关系运算
指针与指针比较大小，地址与地址比较大小。
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
int sz = sizeof(arr) / sizeof(arr[0]);
int* p = &arr;
while (p < arr + sz)//指针的大小比较
{
printf("%d", *p);
p++;
}
return 0;
}野指针
野指针：指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）
野指针成因
指针未初始化
int main()
{
int* p;//局部变量指针未初始化
*p = 20;
return 0;
}
//一个局部变量不初始化，默认值为随机值指针越界访问
int main()
{
int arr[10] = { 0 };
int* p = &arr[0];
int i = 0;
for (i = 0; i <= 11; i++)
{
*(p++) = i;
}
return 0;
}当指针指向的范围超出数组arr的范围时，p就是野指针
指针指向的空间已释放
int* test()
{
int n = 100;
return &n;
}
//当函数结束时，其占用的空间就会被释放
int main()
{
int* p = test();
printf("%d\n", *p);
return 0;
}规避野指针
使用空指针（NULL）初始化指针变量，如果不知道指针应该指向哪里，就可以给指针赋值NULL，在指针释放后将其设置为NULL。NULL的值是0，0也是地址，这个地址是无法使用的，读写该地址会报错。只要是NULL指针就不去访问，同时使用指针之前可以判断指针是否为NULL
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = &arr[0];
for (int i = 0; i < 10; i++)
{
*(p++) = i;
}//此时p已经越界，可以把p置为NULL
p = NULL;
//下次使用的时候，判断p不为NULL的时候再使用
p = &arr[0];
if (p != NULL)
{
}
return 0;
}确保指针始终指向有效的内存地址，检查指针的有效性后再进行访问
assert断言
assert.h头文件定义了宏assert(),用于在运行时确保程序符合指定条件，如果不符合，就报错终止运行，这个宏被称为“断言”。
assert(p != NULL);assert()接受一个表达式作为参数，如果表达式为真，就不会产生任何作用，程序继续运行。如果表达式为假，程序就会报错
- 出错时，直接会报错并且指明在什么文件哪一行
- assert宏可以通过编译选项进行启用或禁用。不使用assert()时，在#include<assert.h>前面定义一个宏 "#define NDEBUG"
assert宏在linux里，realse版本也会起作用。
传值调用与传址调用
写一个函数，交换两个整数类型的变量
传值调用
void Swap(int x,int y)
{
int tmp = x;
x = y;
y = tmp;
}
int main()
{
int a = 20;
int b = 10;
printf("交换前：a= %d b=%d\n",a,b);//交换前：a= 20 b=10
Swap(a, b);
printf("交换后：a= %d b=%d\n",a,b);//交换后：a= 20 b=10
return 0;
} 
为什么这个函数不能完成我们所达到的效果，因为x的地址和a的地址不一样 ，y的地址和b的地址不一样 。x与y是独立的空间，当我们在交换x和y时，a与b的值不会改变。当Swap函数调用结束后回到main函数，a与b的值没有交换。swap函数在使用的时候，是把变量本身直接传给了函数这种就叫传值调用。
实参传递给形参的时候，形参会单独创建一份临时的空间来接收参数，对形参的修改不影响实参
传址调用
要具体解决这个问题就要在main函数中将a和b的地址传给函数，Swap函数里面通过地址间接的操作main函数中a和b的值，这就是传址调用。它可以让函数与主调函数之间建立真正的联系，在函数内部可以修改主调函数中的变量
void Swap(int* px, int* py)
{
int tmp = 0;
tmp = *px;
*px = *py;
*py = tmp;
}
int main()
{
int a = 20;
int b = 10;
printf("交换前：a= %d b=%d\n", a, b);//交换前：a= 20 b=10
Swap(&a, &b);
printf("交换后：a= %d b=%d\n", a, b);//交换后：a= 10 b=20
return 0;
}
1539
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
