进阶-指针

目录

一.指针--what？

二.指针,指针类型 

三.野指针 

 四.指针的运算

五.指针和数组 

六.二级指针 

七.指针数组 

一.指针--what？

什么是指针？

1. 指针是内存中一个最小单元的编号，也就是地址

2.我们 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量。

指针变量：

我们可以通过&（取地址操作符）取出变量的内存其实地址，把地址可以存放到一个变量中，这个变量就是指针变量。

#include <stdio.h>
int main()
{
 int a = 10;//在内存中开辟一块空间
 int *p = &a;//这里我们对变量a，取出它的地址，可以使用&操作符。
    //a变量占用4个字节的空间，这里是将a的4个字节的第一个字节的地址存放在p变量
中，p就是一个之指针变量。
 return 0;
 }

 指针变量，用来存放地址的变量。（存放在指针中的值都被当成地址处理）。

指针是用来存放地址的，地址是唯一标示一块地址空间的。

指针的大小在32位平台是4个字节，在64位平台是8个字节。

二.指针,指针类型 

变量有不同的类型，整形，浮点型等。那指针有没有类型呢？

当然是有的。

我们给指针变量相应的类型。

char   *pc = NULL;

int   *pi = NULL;

short *ps = NULL;

long   *pl = NULL;

float *pf = NULL;

double *pd = NULL;

可以看出，指针的定义方式是： type + *。

其实：

char* 类型的指针是为了存放 char 类型变量的地址。

short* 类型的指针是为了存放 short 类型变量的地址。

int* 类型的指针是为了存放 int类型变量的地址。

#include<stdio.h>
int main()
{
	int a = 10;
	int* pa = &a;
	char* pc = &a;
	printf("%p\n", pa);
	printf("%p\n", pc);

	printf("%p\n", pa+1);
	printf("%p\n", pc+1);

	return 0;
}

 

 可以看出pa，pc存放的一样，pa+1比pa大4（往后跳过4个字节），pc+1比pc大1（往后跳了一个字节）。

即：指针的类型决定了指针向前或者向后走一步有多大（距离）。

#include <stdio.h>
int main()
{
int n = 0x11223344;
char *pc =(char*) &n;
int *pi = &n;
*pc = 0;   //重点在调试的过程中观察内存的变化。
*pi = 0;   //重点在调试的过程中观察内存的变化。
return 0;
}

在内存调试中，pc ：00 33 22 11

                           pi：00 00 00 00

所以：指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）。

比如： char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节。

三.野指针 

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

 示例1：（指针未初始化）

#include <stdio.h>
int main()
{ 
 int *p;//局部变量指针未初始化，默认为随机值
    *p = 20;
 return 0;
 }

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    int *p = arr;
    int i = 0;
    for(i=0; i<=11; i++)
   {
        //当指针指向的范围超出数组arr的范围时，p就是野指针，即当i=5的时候，就发生越界的情况，导致p成为野指针。
        *(p++) = i;
   }
    return 0;
 }

#include<stdio.h>
int *test()
{
  int a=10;
  printf("%d\n",a);
  return &a;
}           //设置个变量a，当返回a的地址时，因为是局部变量，出来test()函数后，就自动销毁，这时候p就是“非法访问”了。
int main()
{
  int *p=test();
  *p=100;
 return 0;
}

 四.指针的运算

1.指针+-整数

#define N_VALUES 5
float values[N_VALUES];
float *vp;
//指针+-整数；指针的关系运算
for (vp = &values[0]; vp < &values[N_VALUES];)   //比较地址的大小
{
     *vp++ = 0; 
}

2.指针-指针

前提：指针-指针是，两个指针必须指向同一个空间。

指针-指针所得到的是指针和指针之间元素的个数。

#include<stdio.h>
int main()
{
   int arr[10]={0};
   printf("%d\n",&arr[9])-&arr[0]); 
    
   return 0;
}

3.指针关系运算

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

经判断条件符合，进入--vp；values[4]=0；没有调整，在判断，则vp接着--，一直下去，直到vp到values[0]的地址，这时不满足判断条件，结束循环。

代码简化：

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

实际在绝大部分的编译器上是可以顺利完成任务的，然而我们还是应该避免这样写，因为标准并不保证它可行。

标准规定：

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

五.指针和数组 

数组名是数组首元素地址。

#include<stdio.h>
int main()
{
   int arr[10]={1,2,3,4,5,6,7,8,9,10};

   printf("%p\n",arr);
   printf("%p\n",arr[0]);
   return 0;
}

有两个例外：

1.sizeof（数组名），数组名表示整个数组，计算的是整个数组的大小。

2.&数组名，数组名表示整个数组，取出的是整个数组的地址。

既然可以把数组名当成地址存放到一个指针中，我们使用指针来访问一个就成为可能

int main()
{
 int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
 int *p = arr; //指针存放数组首元素的地址
 int sz = sizeof(arr) / sizeof(arr[0]);
 int i = 0;
 for (i = 0; i<sz; i++)
 {
 printf("%d ", *(p + i));
 }
 return 0; 
}

 所以 p+i 其实计算的是数组 arr 下标为i的地址。

六.二级指针 

#include<stdio.h>
int main()
{
   int a=10;
   int * pa=&a;         //pa是一级指针
   int * *ppa=&pa;      //ppa是二级指针
   
   return 0;
}

*pa  --  *  告诉我们pa是指针，int说明pa指向是int类型的数据

* *pa  --  *  告诉我们*ppa是指针，int*说明pa指向是int*类型的数据

七.指针数组 

整形数组：存放整形
字符数组：存放字符
指针数组 – 存放指针的数组

指针数组是数组！！！
比如：int* parr[5];  //int*即说明这个数组的类型是整形指针的数组。