【C语言】指针概述

1. 指针和指针类型

1.1 指针的定义

在计算机科学中，指针（Pointer）是编程语言中的一个对象，利用地址，它的值直接指向
（points to）存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。因此，将地址形象化的称为"指针”，意思是通过它能找到以它为地址的内存单元。

每个内存单元都对应着一个由二进制数字组成的地址，而这个地址就是指针。指针是个变量，存放内存单元的地址。话不多说，上代码：

int main()
{
    int a = 10;
    int* p = &a;    //指针变量
    return 0;
}

一般由于存放地址的变量称为指针变量。因此，p里面存的是地址，而p本身又叫指针变量，所以可以说指针就是地址，地址就是指针。

总结：

• 在32位的机器上，地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以一个指针变量的大小就应该是4个字节。
• 那如果在64位机器上，如果有64个地址线，那一个指针变量的大小是8个字节，才能存放一个地址。
• 指针是用来存放地址的，地址是唯一标示一块地址空间的。
• 指针的大小在32位平台是4个字节，在64位平台是8个字节。

1.2 指针类型

变量类型如下表所示：

代码	含义
char	字符型（1字节） 2^8
short	短整型（2字节）2^16
int	整型（4字节） 2^32
long	长整型（8字节）2^64
float	单精度浮点型（4字节）2^32
double	双精度浮点型（8字节）2^32

而对应的指针类型如下表：

代码	含义
char*	字符型指针
short*	短整型指针
int*	整型指针
long*	长整型指针
float*	单精度浮点型指针
double*	双精度浮点型指针

指针类型决定了指针进行解引用操作的时候，能够访问空间的大小。

int* p；* p能够访问4个字节

char* p；* p能够访问1个字节

double* p：* p能够访问8个字节

…依照不同变量类型所占字节大小依此类推

由于不同的指针类型能够访问的空间大小不同，所以指针类型也决定了指针走一步能走多远（即指针的步长）。例如：

int main()
{
	int a = 0x11223344;
	int* pa = &a;
	char* pc = &a;
	printf("%p\n", pa);
	printf("%p\n", pa+1);
	printf("%p\n", pc);
	printf("%p\n", pc+1);
	return 0;
}

结果为：

0000005947CFFCC4
0000005947CFFCC8
0000005947CFFCC4
0000005947CFFCC5

总结：

• 指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节），比如：char *的指针解引用就只能访问一个字节，而int *的指针的解引用就能访问四个字节。

• 指针+整数或指针-整数。指针的类型决定了指针向前或向后走一步有多大的距离（单位：字节）。例如

  int main()
  {
  	int arr[10] = {0};
  	int* p = arr;    //数组名等于首元素地址
  	int i = 0;
  	for (i = 0; i < 10; i++)
  	{
  		*(p + i) = 1;
  	}
  	return 0;
  }
  

  利用指针+整数的形式可以改变数组的元素值；

2. 野指针

2.1 概念

野指针就是指针指向的位置是不可知的（随机的，不正确的，没有明确限制的）

2.2 导致野指针的原因

• 局部变量不初始化，默认是随机值

  int main()
  {
      int a;    //局部变量不初始化，默认是随机值
      int* p;   //局部指针变量不初始化，默认是随机值，野指针
  	return 0；
  }
  

• 指针越界访问，也会导致野指针

  int main()
  {
      int arr[10] = {0};
      int* p = arr;
      int i = 0;
      for (i=0;i<12;i++)
      {
          *(p+i) = i;    
          //当指针指向的范围超过数组arr的范围时，会产生越界，导致野指针
      }
      return 0;
  }
  

• 指针指向的内存空间释放了，导致野指针

  int* test()
  {
      int a = 10;
      return &a;
  }
  
  int main()
  {
      int* p = test();  //执行完此语句之后，test函数已经执行完毕，那么a的内存已经被释放了（因为执行了return），下面的解引用操作可能就是对别的项目在该内存地址的值进行赋值，会产生问题。
      *p = 20;
      return 0;
  }
  

2.3 如何避免野指针

• 指针初始化

• 当不知道指针应该初始化谁时，就给它初始化为空指针NULL

  int* p = NULL;	//其实就是将0强制转换为空指针0x00000000
  

• 防止指针越界

• 指针指向空间释放后需要将指针置为NULL

• 使用指针之前检测指针的有效性

  int main()
  {
      int a = 10;
      int* pa = &a;
      *pa = 20;
      pa = NULL;			//指针使用完成，释放，设为NULL
      if (pa != NULL)		//if语句检测指针的有效性
      {
          //执行对应的语句
      }
  }
  

3. 指针运算

3.1 指针±整数

指针±整数就是实现指针按照固定步长去访问内存地址

int main()
{
	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int i = 10;
	int sz = sizeof(arr) / sizeof(arr[0]);
	int* p = arr;
	for (i = 0; i < sz; i++)
	{
		printf("%d", *p);
		p = p + 1;//p++//p+=2//......
	}
	return 0;
}

3.2 指针-指针

int main()
{
	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
	printf("%d\n", &arr[9] - &arr[0]);
	return 0;
}

//结果为9

所以，指针-指针得到的两指针之间的元素个数。两个指针一定要指向同一块空间，否则得到的结果无意义。

【C语言标准】

允许指向数组元素的指针与指向数组最后一个元累后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较。

应用：求数组或字符串的长度

int mystrlen(char* str)
{
	char* start = str;
	char* end = str;
	while (* end != '\0')
	{
		end++;
	}
	return end - start;
}

int main()
{
	char ch[] = "bit";
	int len = mystrlen(ch);
	printf("%d\n", len);
	return 0;
}

3.3 指针的关系运算

#define N_VALUES 5
float values[N_VALUES];
float *vp;
for (vp = &values[N_VALUES]; vp>&values[0];)
{
    *vp--=0;
}

4. 指针与数组

4.1 数组名绝大多数情况下是首元素地址

int main()
{
	int arr[10] = { 0 };
	printf("%p\n", arr);
	printf("%p\n", arr+1);
	printf("%p\n", &arr[0]);
	printf("%p\n", &arr[0]+1);
	printf("%p\n", &arr);
	printf("%p\n", &arr+1);
	return 0;
}

数组名绝大多数情况下是首元素地址，但在以下两种情况下数组名不是首元素地址：

• &arr即&数组名：此时数组名表示整个数组，取出的是整个数组的地址
• sizeof(arr)即sizeof(数组名)：此时数组名表示整个数组，sizeof(数组名)计算的是整个数组的大小，单位是字节。

4.2 数组可通过指针访问

int main()
{
	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int i = 10;
	int* p = arr;
	for (i = 0; i < 10; i++)
	{
		printf("%p ==========>> %p\n", p+i, &arr[i]);
	}
	return 0;c
}

int main()
{
	int arr[10] = { 0 };
	int i = 10;
	int* p = arr;
	for (i = 0; i < 10; i++)
	{
		*(p+i) = i;
	}
    for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;c
}

5. 二级指针

int main()
{
    int a = 0;
    int * pa = &a;
    int* * ppa = &pa;    //二级指针
    return 0;
}

一级指针变量的地址就是二级指针，同理还有三级指针等

指针数组的定义：

int main()
{
    int a = 0;
    int b = 1;
    int c = 2;
    int* arr[3] = {&a, &b, &c};    //指针数组
    return 0;
}