1. 内存和地址
1.1 内存
我们知道CPU(中央处理器)在处理数据的时候，需要的数据在内存中读取，处理后的数据也会放回内存中。那么如何提高内存空间的管理呢？其实也就是把内存分为一个个内存单元，每个内存单元的大小是一个字节，其中一个字节的大小相当于8个比特位(bit)。每一个内存单元都有一个编号，通过这个编号CPU就可以快速的找到这块内存空间，这个编号我们叫做地址。C语言中给地址起了个新名字叫指针。
所以我们可以理解为: 内存单元的编号==地址==指针
计算机中常见的单位换算: 1b yte = 8b it 1 KB = 1024b yte 1 MB = 1024 KB 1 GB = 1024 MB 1 TB = 1024 GB 1 PB = 1024 TB1.2 究竟该如何理解编址
CPU在访问内存中的某个字节空间时必须知道这个内存空间在什么位置，而因为内存中有很多字节，所以需要给内存镜像编址(如同宿舍好多需要给宿舍编号一样)。计算机的内存编址，并不是把每个字节都记录下来，而是通过硬件设计完成的。(如钢琴，吉他上没有写音符的信息，但是表演者这样可以准确的找到每一个音的位置，这是因为制造商已经将乐器在硬件层面设计好了，且演奏者知道。本质上是一种约定俗成的共识)。
2. 指针变量和地址
2.1 取地址操作符(&)
了解了内存与地址之间的关系，回到C语言，在C语言中创建变量其实就是向内存申请空间。如:
上述代码结束创建了一个整型变量啊，在内存中申请了3给字节的空间，用于存放10这个整数。
那么如何获得地址呢？这里就要学习一个新的操作符(&)-取地址操作符。
由图我们可以知道&a所占4给字节中地址较小的地址。虽然整型变量占⽤4个字节，我们只要知道了第⼀个字节地址，顺藤摸⽠访问到4个字节的数据也是可⾏的。
2.2 指针变量和解引⽤操作符(*)
2.2.1 指针变量 我们通过取地址操作符(&)拿到一个地址的值，这个值有时候需要储存起来，方便后期使用，那我们要如何储存这样的地址值呢？答案是放在指针变量里。如:#include<stdio.h>
main()
{
int a = 10;
int* pa = &a;//取a的地址放到pa里
return 0;
}指针变量也是一种变量，是专门用来存放地址的，存放在指针变量中的值都会理解为地址。
2.2.2 如何拆解指针类型 我们看到pa的类型是 int* ，我们该如何理解指针的类型呢？ 这⾥pa左边写的是 int* ， * 是在说明pa是指针变量，⽽前⾯的 int 是在说明pa指向的是整型(int) 类型的对象。
2.2.3
解引⽤操作符
我们将地址保存起来，未来是要使⽤的，那怎么使⽤呢？
在现实⽣活中，我们使⽤地址要找到⼀个房间，在房间⾥可以拿去或者存放物品。
C语⾔中其实也是⼀样的，我们只要拿到了地址(指针)，就可以通过地址(指针)找到地址(指针)指向的对象，这⾥必须学习⼀个操作符叫解引⽤操作符(*)。
#include<stdio.h>
main()
{
int a = 10;
int* pa = &a;
*pa = 0;
return 0;
}#include<stdio.h>
main()
{
printf("%zd\n", sizeof(char*));
printf("%zd\n", sizeof(short*));
printf("%zd\n", sizeof(int*));
printf("%zd\n", sizeof(double*));
return 0;
}
结论：
•
32位平台下地址是32个bit位，指针变量⼤⼩是4个字节
•
64位平台下地址是64个bit位，指针变量⼤⼩是8个字节
•
注意指针变量的⼤⼩和类型是⽆关的，只要指针类型的变量，在相同的平台下，⼤⼩都是相同的。
3. 指针变量类型的意义
指针变量的⼤⼩和类型⽆关，只要是指针变量，在同⼀个平台下，⼤⼩都是⼀样的，为什么还要有各种各样的指针类型呢？ 其实指针类型是有特殊意义的，我们接下来继续学习。 3.1 指针的解引⽤
#include <stdio.h>
int main()
{
int n = 10;
char* pc = (char*)&n;
int* pi = &n;
printf("n= %p\n", &n);
printf("pc= %p\n", pc);
printf("pc+1=%p\n", pc + 1);
printf("pi= %p\n", pi);
printf("pi+1=%p\n", pi + 1);
return 0;
}运行结果:
#include <stdio.h>
int main()
{
int a = 10;
int* pa = &a;
char* pc = &a;
return 0;
}
#include <stdio.h>
int main()
{
int a = 10;
void* pa = &a;
void* pc = &a;
*pa = 10;
*pc = 0;
return 0;
}
4. const修饰指针
4.1 const修饰变量 变量是可以修改的，如果把变量的地址交给⼀个指针变量，通过指针变量的也可以修改这个变量。 但是如果我们希望⼀个变量加上⼀些限制，不能被修改，怎么做呢？这就是const的作⽤。#include <stdio.h>
int main()
{
int m = 0;
m = 20;//m是可以修改的
const int n = 0;
n = 20;//n是不能被修改的
return 0;
}
#include <stdio.h>
int main()
{
const int n = 0;
printf("n = %d\n", n);
int* p = &n;
*p = 20;
printf("n = %d\n", n);
return 0;
}
void test1()
{
int n = 10;
int m = 20;
int* p = &n;
*p = 20;
p = &m;
}
#include<stdio.h>
main()
{
test1();
return 0;
}
void test2()
{
int n = 10;
int m = 20;
const int* p = &n;
*p = 20;
p = &m;
}
#include<stdio.h>
main()
{
test2();
return 0;
}
void test3()
{
int n = 10;
int m = 20;
int* const p = &n;
*p = 20;
p = &m;
}
#include<stdio.h>
main()
{
test3();
return 0;
}
void test4()
{
int n = 10;
int m = 20;
int const* const p = &n;
*p = 20; //ok?
p = &m; //ok?
}
#include<stdio.h>
main()
{
test4();
return 0;
}
结论：const修饰指针变量的时候 • const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。但是指针变量本⾝的内容可变。 • const如果放在*的右边，修饰的是指针变量本⾝，保证了指针变量的内容不能修改，但是指针指向的内容，可以通过指针改变。
5. 指针运算
指针的基本运算有三种，分别是： • 指针+- 整数 • 指针-指针 • 指针的关系运算 5.1 指针+- 整数 因为数组在内存中是连续存放的，只要知道第⼀个元素的地址，顺藤摸⽠就能找到后⾯的所有元素。int arr[10] = {1,2,3,4,5,6,7,8,9,10};
#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;运行结果:
#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;
}运行结果:
#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]);
while(p<arr+sz) //指针的⼤⼩⽐较
{
printf("%d ", *p);
p++;
}
return 0;
}运行结果:
6. 野指针
概念： 野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）
6.1 野指针成因 6.1.2 指针未初始化#include <stdio.h>
int main()
{
int *p;//局部变量指针未初始化，默认为随机值
*p = 20;
return 0;
}#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;
}#include <stdio.h>
int* test()
{
int n = 100;
return &n;
}
int main()
{
int* p = test();
printf("%d\n", *p);
return 0;
}#include <stdio.h>
int main()
{
int num = 10;
int*p1 = #
int*p2 = NULL;
return 0;
}#include<stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,67,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];//重新让p获得地址
if (p != NULL) //判断
{
//...
}
return 0;
}7. assert断言
assert.h 头⽂件定义了宏 assert() ，⽤于在运⾏时确保程序符合指定条件，如果不符合，就报 错终⽌运⾏。这个宏常常被称为“断⾔”。 assert(p != NULL);#define NDEBUG
#include <assert.h>8. 指针的使用和传址调用
8.1 传值调⽤和传址调⽤ 学习指针的⽬的是使⽤指针解决问题，那什么问题，⾮指针不可呢？ 例如：写⼀个函数，交换两个整型变量的值 ⼀番思考后，我们可能写出这样的代码：#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;
}运行结果:
并没有精选交换，我们可以调试一下看看:
#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;
}运行结果:
