指针讲解（1） 初步了解C语言指针（概念分析＋基础示例代码）

前言

      C语言指针可以说是让C语言初学者最头疼的部分之一，原因不乏有概念难理解，就算概念理解了上手敲代码依然困难重重，当然这都可以理解，因为其概念机器抽象，且打破了C语言初学者养成的“直接数据操作”思维，突然转化为间接访问的抽象层。接下来我会由浅入深的分析指针，让大家更容易理解（可作为初步了解后的辅助加深记忆，不建议初学者完全依赖学习）

1、内存和地址

     计算机CPU在处理数据时，所需的数据都是在内存中读取的，处理后的数据会放到内存中，我们可以把内存分解为一个个的内存单元，每个内存单元的大小分为一个字节。一个比特位能存储一个二进制的位1或0

每个内存单元能存储8个比特位，而且每个内存单元有一个编号，方便CPU找到内存空间，这个编号就是地址，也可以叫做指针。CPU访问内存的某个字节空间，必须知道这个字节空间的内存在什么位置。因为内存中字节很多，所以要进行编址方便CPU查找。编址并不是把每个字节的地址记录下来，而是通过硬件设计完成的。
计算机内部有很多的硬件单元，这些硬件单元互相协同工作，协同就是互相之间至少能进行数据传递。CPU和内存之间有大量的数据交互，两者必须用线连起来，其中一组线就是地址总线

2：指针变量和地址

     为了理解内存和地址的关系，我来举个例子

#include<stdio.h>
int main()
{
	int a=10;
	return 0;
}

我创建了一个整型变量a，并赋值为10，因为是int类型，所以想内存申请空间为4个字节。这里就涉及到一个取地址操作符&

#include<stdio.h>
int main()
{
	int a=10;
	&a;//取出的地址
	printf("%p\n",&a);
	return 0;
}

运行结果为

虽然整型变量占用4个字节，但是我们只要知道了第一个字节位置，访问到4个字节的数据也是可以的

我们通过取地址操作符得到的地址是一个数值，但是我们需要把这个地址值存在哪里？在指针变量中。

#include<stdio.h>
{
	int a=10;
	int *pa=&a;//取出a的地址并存储到&a中
	return 0；
}

指针变量本质上也是变量，这种变量是存放地址的，存在指针变量的值都会理解为地址

接下来我们了解以下指针类型

int a=10;
int *pa=&a;

这里我们看到，pa的类型为int*
这里的“ * ”就在说明pa是指针变量，前面的int代表pa指向的是整型类型的对象。
如果有charl类型的ch，ch的地址应该怎么存放？

char ch="w";
pc=&ch;

我们需要把地址保存起来，以后能用
只要我们拿到了地址，就可以通过地址找到地址指向的对象，这里介绍一个很有用的工具叫做解引用操作符（*）

#include<stdio.h?
{
	int a=100;
	int *pa=&a;
	*pa=0;
	return 0;
}

*pa指向的是a的地址，（pa）就是通过pa存放的地址，找到指向的空间，pa就基本是a变量了，所以pa=0，相当于让a=0

32位机器有32根总线，同理64位也有64根总线，一个地址就是64位二进制位组成的二进制序列，存储起来需要8个字节的空间，指针变量的大小就是8字节

#include<stdio.h>
int main()
{
	printf("%zd\n",sizeof(char*));
	printf("%zd\n",sizeof(short*));
	printf("%zd\n",sizeof(int*));
	printf("%zd\n",sizeof(double*));
}

这段代码x64和x86的运行结果不一样
这个是x86的

这个是x64的

32位平台下地址是32个bit位，指针变量大小是4个字节
64位平台下地址是64个bit位，指针变量大小是8个字节

指针变量类型意义

指针的解引用

#include<stdio.h>
int main()
{
	int n=0x11223344;
	int *pi=&n;
	*pi=0;
	return 0;
}

这段代码会将n的四个字节全部改成0，因为是int类型。所以指针的类型决定了指针的解引用的权限，由此可以推断出char*只能访问一个字节
指针＋整数

#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;
}

此代码的运行结果

从这里我们可以看出char的指针变量跳过一个字节，int类型的指针变量加一就跳过了4个字节，指针+1就是跳过一个指针所指向的元素
void*指针
void*类型可以理解为无具体类型的指针，可以接受任意地址，但是也有局限性，不能直接进行指针的加减整数和解引用的运算

#include <stdio.h>
int main()
{
	 int a = 10;
	 int* pa = &a;
	 char* pc = &a;
	 return 0;
}

在上⾯的代码中，将⼀个int类型的变量的地址赋值给⼀个char类型的指针变量。编译器给出了⼀个警
告（如下图），是因为类型不兼容。⽽使⽤void类型就不会有这样的问题。

void*类型的指针可以接收不同类型的地址，但是无法直接进行指针运算
const修饰指针
变量是可以修改的，如果把变量的地址交给⼀个指针变量，通过指针变量的也可以修改这个变量。
但是如果我们希望⼀个变量加上⼀些限制，不能被修改，怎么做呢？这就是const的作⽤。

#include<stdio.h>
int main()
{
	int m=0;
	m=20;
	const int n=0;
	n=20;
	return 0;
}

上述代码中n是不能被修改的，其实n本质是变量，只不过被const修饰后，在语法上加了限制，只要我
们在代码中对n就⾏修改，就不符合语法规则，就报错，致使没法直接修改n。

#include<stdio.h>
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;
 int const * const p = &n;
 *p = 20; 
 p = &m; 
}
int main()
{
 test1();
 test2();
 test3();
 test4();
 return 0;
}

结论：const修饰指针变量时。如果在*的左边，修饰指针指向的内容，保证指针内容不能通过指针来改变，但是指针变量本身可以改变。如果在右面，修饰指针变量本身，保证指针变量的内容不可修改，但是指针指向的内容，可以通过指针改变
指针运算
有三种运算，指针±整数，指针-指针，指针的关系运算
指针±整数

#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));
 }
 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 sz = sizeof(arr)/sizeof(arr[0]);
 while(p<arr+sz) 
 {
 printf("%d ", *p);
 p++;
 }
 return 0;
}

野指针
野指针就是指针指向的位置是不可知的
导致原因1：指针未初始化

#include <stdio.h>
int main()
{ 
 int *p;
 *p = 20;
 return 0;
}

2.指针越界访问

#include <stdio.h>
int main()
{
 int arr[10] = {0};
 int *p = &arr[0];
 int i = 0;
 for(i=0; i<=11; i++)
 {
 *(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;
}

如何规避野指针？
可以赋值NULL，NULL值是0，0也是地址，但是无法使用，都城地址会报错

assert 断言

assert(p!=NULL);

需要在头文件定义宏assert()，如果assert内的条件符合，会正常运行，如果不符合就会报错
只不过这个有一个缺点就是增加了额外的检查，增加了程序的运行时间，再Release中禁用assert就行，通常是在debug中使用的

指针的使用和传址调用
strlen的实现，统计\0之前的字符个数

size_t strlen ( const char * str );

遍历字符串，一直到\0位置

int my_strlen(const char * str)
{
 int count = 0;
 assert(str);
 while(*str)
 {
 count++;
 str++;
 }
 return count;
}
int main()
{
 int len = my_strlen("abcdef");
 printf("%d\n", len);
 return 0;
}

传值调⽤和传址调⽤

#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;
}

此代码运行后并没有进行交换
我们发现在main函数内部，创建了a和b，a的地址是0x00cffdd0，b的地址是0x00cffdc4，在调⽤
Swap1函数时，将a和b传递给了Swap1函数，在Swap1函数内部创建了形参x和y接收a和b的值，但是
x的地址是0x00cffcec，y的地址是0x00cffcf0，x和y确实接收到了a和b的值，不过x的地址和a的地址不
⼀样，y的地址和b的地址不⼀样，相当于x和y是独⽴的空间，那么在Swap1函数内部交换x和y的值，
⾃然不会影响a和b，当Swap1函数调⽤结束后回到main函数，a和b的没法交换。Swap1函数在使⽤的时候，是把变量本⾝直接传递给了函数，这种调⽤函数的⽅式我们之前在函数的时候就知道了，这种叫传值调⽤。

#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;
}

我们现在要解决的就是当调⽤Swap函数的时候，Swap函数内部操作的就是main函数中的a和b，直接将a和b的值交换了。那么就可以使⽤指针了，在main函数中将a和b的地址传递给Swap函数，Swap函数⾥边通过地址间接的操作main函数中的a和b，并达到交换的效果就好了。