目录
1.内存和地址
(1)内存被划分为一个个的单元，一个内存单元大小为1个字节（8个比特位），一个比特位可以存储一个2进制位的位1或者0；
(2)每个内存单元都给一个编号，这个编号就是地址，C语言又把地址称为：指针；
内存单元的编号=地址=指针
(3)编址：CPU和内存之间的数据交互通过地址总线连接；32位机器有32根地址总线，总共能表示2^32种含义，每种含义代表一个地址；
地址信息被下达给内存，在内存上就可以找到该地址对应的数据，将数据通过数据总线传⼊CPU内寄存器。
2.指针变量和地址
2.1.取地址操作符(&)
#include <stdio.h>
int main()
{
int a = 10;
&a;//取出a的地址
printf("%p\n", &a);//%p专门用于取地址
return 0;
}
(1)指针：地址； 指针变量：存放地址；口头语所说的指针通常为指针变量；
(2)取地址只需取一个(4个字节中较小的)；
2.2.指针变量和解引用操作符(*)
(1)数值的地址值存放于指针变量中；
(2)指针变量也是一种变量，用于存放地址(地址又被称为指针)，存放在指针变量中的值均被理解为指针；
#include <stdio.h>
int main()
{
int a = 10;
int* pa = &a;//取出a的地址并存储到指针变量pa中
//int* pa
//*说明pa为指针变量；
//int说明pa指向的是int类型的变量
return 0;
}(3)指针变量是专门用来存放地址的，指针变量的大小取决于一个地址所需空间：
1>32位平台下地址是32个bit位，指针变量⼤⼩是4个字节；
(32位机器：地址线为32根，地址二进制序列为32比特位，需要4个字节空间，即32比特位空间；所以，32位机器上指针变量大小为4个字节)
2>64位平台下地址是64个bit位，指针变量⼤⼩是8个字节；
3>注意指针变量的⼤⼩和类型是⽆关的，只要指针类型的变量在相同的平台下，⼤⼩都是相同的。
int main()
{
int a = 100;
int* pa = &a;//等价于：*pa == a
*pa = 0;
return 0;
}2.3.指针变量类型的含义
(1)指针的类型决定了对指针解引⽤的时候有多⼤的权限（⼀次能操作⼏个字节);
⽐如：char*的指针解引⽤只能访问⼀个字节，⽽int*的指针解引⽤能访问四个字节。
(2)指针的类型决定了指针向前或者向后⾛⼀步有多⼤（距离）;
比如：char*类型的指针变量+1跳过1个字节，int*类型的指针变量+1跳过了4个字节。
这就是指针变量的类型差异带来的变化。
#include <stdio.h>
int main()
{
int n = 10;
char *pc = (char*)&n;
int *pi = &n;
printf("%p\n", &n);
printf("%p\n", pc);
printf("%p\n", pc+1);
printf("%p\n", pi);
printf("%p\n", pi+1);
return 0;
}
(3) void*类型的指针可以⽤来接受任意类型地址，但其不能直接进⾏指针的+-整数和解引⽤的运算；
#include <stdio.h>
int main()
{
int a = 10;
void* pa = &a;//
void* pc = &a;//void*类型指针不能直接进行解引用操作
*pa = 10;
*pc = 0;
//pc++：错误，void*类型指针不能直接进行运算
return 0;
}(4) ⼀般void*类型的指针是使⽤在函数参数的部分，⽤来接收不同类型数据的地址；当不能确定指针类型时可以采用void*接收。
3.const修饰指针
(1)const修饰变量： 将变量的地址交给指针变量，通过指针变量可以修改这个变量。而如果变量被const修饰，就没办法修改了(但如果绕过n使用其地址去修改n就可以做到修改变量)。
#include <stdio.h>
int main()
{
const int n = 0;//此时n不能被修改
printf("n = %d\n", n);
int *p = &n;//取n的地址
*p = 20;//通过修改指针变量修改n
printf("n = %d\n", n);
return 0;
}
//p里面存放的是地址
//p是变量，有自己的地址
//*p是p指向的空间(2)const修饰指针变量：
const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。但是指针变量本⾝的内容可变。
const如果放在*的右边，修饰的是指针变量本⾝，保证了指针变量的内容不能修改，但是指针指向的内容，可以通过指针改变。
#include<stdio.h>
//代码1
void test1()
{
int n = 10;
int m = 20;
int* p = &n;
*p = 20;//ok
p = &m; //ok
}
void test2()
{
//代码2
int n = 10;
int m = 20;
const int* p = &n;//*p不能改但p可改
*p = 20;//no
p = &m;//ok
}
void test3()
{
int n = 10;
int m = 20;
int* const p = &n;//p不可改但*p可改
*p = 20;//ok
p = &m; //no
}
void test4()
{
int n = 10;
int m = 20;
int const* const p = &n;//p和*p均不可改
*p = 20; //no
p = &m; ///no
}
int main()
{
//测试⽆const修饰的情况
test1();
//测试const放在*的左边情况
test2();
//测试const放在*的右边情况
test3();
//测试*的左右两边都有const
test4();
return 0;
}
4.指针运算
(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 这⾥就是指针+整数(i*sizeof(int))
}
return 0;
}
(2)指针-指针：
//指针-指针
#include <stdio.h>
int my_strlen(char* s)
{
char* p = s;
while (*p != '\0')
p++;
return p - s;
//&arr[0]-&arr[9]=9:指针-指针的绝对值是指针和指针之间的元素个数(前提：两个指针指向的是同一块空间)
}
int main()
{
printf("%d\n", my_strlen("abc"));
//int len=strlen("abc");统计的是'\0'之前的字符个数
return 0;
}
(3)指针的关系运算(指针比大小=地址比大小)
//指针的关系运算
#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]);//10
while (p < arr + sz) //指针的⼤⼩⽐较
//arr是数组名，数组名其实是数组首元素地址：arr=&arr[0]
{
printf("%d ", *p);//所以此处*p指的是取第一个元素
p++;
}
return 0;
}5.野指针
5.1.野指针成因
野指针就是指针指向的位置是不可知的(随机的、不正确的、没有明确限制的)。
(1)指针未初始化：局部变量不初始化，变量值为随机的 ccccc；全局变量(静态变量，储存在静态区)不初始化，变量值默认为0；
#include <stdio.h>
int main()
{
int *p;//局部变量指针未初始化，默认为随机值
*p = 20;
return 0;
}(2)指针越界访问：
#include <stdio.h>
int main()
{
int arr[10] = {0};//只有10个内存空间
int *p = &arr[0];
int i = 0;
for(i=0; i<=11; i++)//指向11时就为野指针
{
//当指针指向的范围超出数组arr的范围时，p就是野指针
*(p++) = i;
}
return 0;
}(3)指针指向的空间释放：
#include <stdio.h>
int* test()
{
int n = 100;
return &n;
}
int main()
{
int *p = test();
printf("%d\n", *p);
return 0;
}5.2.规避野指针
(1)指针初始化：
//指针初始化
//明确知道pa应指向a，所以拿a的地址初始化
int a = 10;
int *pa = &a;
//可能不知道指针初始化谁的地址，所以直接赋值NULL
int *p = NULL
(2)小心指针越界：通过指针只能访问程序向内存申请的空间，确保不超出范围；
(3)避免返回局部变量的地址
(4)指针变量不再使用时及时置NULL，指针使用之前检查有效性：
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8,9,10};
int *p = &arr[0];
for(i=0; i<10; i++)
{
*(p++) = i;
}
//出循环时代表p已经达到了数组申请的最大内存空间
//此时p已经越界了，可以把p置为NULL
p = NULL;
//下次使⽤的时候，判断p不为NULL的时候再使⽤
//...
p = &arr[0];//重新让p获得地址
if(p != NULL) //判断
{
//...
}
return 0;
}
6.assert断言
assert.h头⽂件定义了宏 assert() ，⽤于在运⾏时确保程序符合指定条件，如果不符合就报错终⽌运⾏。这个宏常常被称为“断⾔”。
assert(p != NULL);
//运行到这一行时，验证变量p是否等于NULL，如果确实不等于就继续运行，等于则报错
使⽤assert()有⼏个好处：它不仅能⾃动标识⽂件和出问题的⾏号，还有⼀种⽆需更改代码就能开启或关闭assert()的机制。如果已经确认程序没有问题，不需要再做断⾔，就在#include<assert.h>语句的前⾯定义⼀个宏NDEBUG：
#define NDEBUG
#include <assert.h>然后重新编译程序，编译器就会禁⽤⽂件中所有的assert()语句。如果程序⼜出现问题，可以移除这条#define NDBUG指令(或者把它注释掉)，再次编译就重新启⽤了assert()语句。assert()的缺点是，因为引⼊了额外的检查而增加了程序的运⾏时间。
⼀般我们可以在Debug中使⽤，在Release版本中选择禁⽤assert就⾏，在VS这样的集成开发环境的Release版本中直接就已经优化掉了。
7.指针的使用和传址调用
7.1.strlen的模拟实现
库函数strlen的功能是求字符串⻓度，统计的是字符串中\0之前的字符的个数。
size_t strlen ( const char * str );//size_t==unsigned int
int my_strlen(const char * str)//str=&a;*str=a
{
int count = 0;
assert(str);
while(*str)
{
count++;
str++;
}
return count;
}
int main()
{
int len = my_strlen("abcdef");//my_strlen(arr)传递的是数组首元素的地址(传址调用)
printf("%d\n", len);
return 0;
}
7.2.传值调用和传址调用
//写一个函数，交换两个整型变量的值
#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);
//交换失败
//x和y确实收到了a和b的值，但&x!=&a，&y!=&b
//相当于x和y是独立的空间，在Swap1函数内部交换x和y的值，不会影响a和b
return 0;
}结论：传值调用：函数实参传给形参的时候，形参是实参的一份临时拷贝，形参有自己的独立空间，对形参的修改不会影响实参。
#include<stdio.h>
void Swap2(int* px, int* py)
{
//传址调用
//将&a和&b传给Swap函数
//交换&x和&a，&y和&b
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);
Swap1(&a, &b);//传址调用：原始值和被调用的值均可以被找到
printf("交换后：a=%d b=%d\n", a, b);
return 0;
}
结论：传址调用：可以让函数和主调函数之间建立真正的联系；如果函数内部要修改主调函数中的变量的值，就需要传址调⽤。
1249
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
