指针1（C语言）

怼烎@ 2024-04-03 11:54 69阅读 0赞

**目录**

1.指针是什么

2. 指针和指针类型

2.1 指针+-整数

2.2 指针的解引用

3. 野指针

3.1 野指针成因

1. 指针未初始化

2. 指针越界访问

3. 指针指向的空间释放

3.2 如何规避野指针

1. 指针初始化

2. 小心指针越界

3. 指针指向空间释放，及时置NULL

4. 避免返回局部变量的地址

5. 指针使用之前检查有效性

4. 指针运算

4.1 指针+-整数

4.2 指针-指针

4.3 指针的关系运算

5. 指针和数组

6. 二级指针

7. 指针数组

--------------------

## 1.指针是什么 ##

指针就是地址，口语中说的指针通常指的是指针变量。

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

内存

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

指针变量是用来存放地址的，地址是唯一标示一个内存单元的。

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

#include<stdio.h>
    int main()
    {
    	int i = 10; //定义了一个整型变量
    	int* p = &i;
    	printf("%d\n", *p);  //*p   -->指向地址的内容      //10
    	printf("%p", p);   //p  --->地址                 //010FFC68
    	return 0;
    }

## 2. 指针和指针类型 ##

类型

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 类型变量的地址。

### 2.1 指针+-整数 ###

printf("%p\\n", &n); //001EFD4C n的地址  
printf("%p\\n", pc); //001EFD4C pc指向n的地址  
printf("%p\\n", pc+1); //001EFD4D pc指向n的下一个地址，pc是char\*类型，所以，下一个是加1  
printf("%p\\n", pi); //001EFD4C pi指向n的地址  
printf("%p\\n", pi+1); //001EFD50 pi指向n的下一个地址，pi是int\*类型，所以，下一个是加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;
    }

指针的类型决定了指针向前或者向后走一步有多大

### 2.2 指针的解引用 ###

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

\*pc = 0; //char 型解引用1个字节  
\*pi = 0; //int 型解引用4个字节  
  
指针类型决定了访问空间的能力

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

## 3. 野指针 ##

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

### 3.1 野指针成因 ###

#### 1. 指针未初始化 ####

局部变量指针未初始化，默认为随机值

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

#### 2. 指针越界访问 ####

当指针指向的范围超出数组arr的范围时，p就是野指针

#include <stdio.h>
    int main()
    {
       int arr[10] = {0};
       int *p = arr;
       int i = 0;
       for(i=0; i<=11; i++)
      {
          
           *(p++) = i;
      }
       return 0;
    }

#### 3. 指针指向的空间释放 ####

### 3.2 如何规避野指针 ###

#### 1. 指针初始化 ####

#### 2. 小心指针越界 ####

#### 3. 指针指向空间释放，及时置NULL ####

####  ####

#### 4. 避免返回局部变量的地址 ####

#### 5. 指针使用之前检查有效性 ####

#include <stdio.h>
    int main()
    {
        //明确初始化
       int *p = NULL;
       //....
       int a = 10;
       p = &a;
       //指针使用之前检查有效性
       if(p != NULL)
      {
           *p = 20;
      }
       return 0;
    }

## 4. 指针运算 ##

### 4.1 指针+-整数 ###

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

\*vp++ = 0;

\*vp++, ++优先级高于\*， 因为是后置++,先赋值，后加 ， 所以解引用是\*=0, 指针指向下一个内存

（\*vp）++ ，先对\*p解引用操作，值++

### 4.2 指针-指针 ###

int my_strlen(char *s)
    {
          char *p = s;
          while(*p != '\0' )
                 p++;
          return p-s;
    }

两个指针相减的前提是：指针指向的同一块连续的空间

int main()
    {
    	
    	int arr[10] = {0};
    	printf("%d\n", &arr[9] - &arr[0]);
    	printf("%d\n", &arr[0] - &arr[9]);
    
    	int a = 10;
    	char c = 'w';
    //	printf("%d\n", &a - &c);//err
    
    	return 0;
    }

指针和指针相减，绝对值为指针之间的个数

### 4.3 指针的关系运算 ###

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

指向第一个元素之前的那个内存位置的指针进行比较。

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

化简后

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

## 5. 指针和数组 ##

数组名表示的是数组首元素的地址

#include <stdio.h>
    int main()
    {
    int arr[10] = {1,2,3,4,5,6,7,8,9,0};
       printf("%p\n", arr);
       printf("%p\n", &arr[0]);
       return 0;
    }

p存放的是数组首元素的地址

int arr[10] = {1,2,3,4,5,6,7,8,9,0};
    int *p = arr;

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

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

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

那我们就可以直接通过指针来访问数组。

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

int main()
    {
    int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
    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;
    }

## 6. 二级指针 ##

\*ppa 通过对ppa中的地址进行解引用，这样找到的是 pa ， \*ppa 其实访问的就是 pa .

int b = 20;
    *ppa = &b;//等价于 pa = &b;

\*\*ppa 先通过 \*ppa 找到 pa ,然后对 pa 进行解引用操作： \*pa ，那找到的是 a .

**ppa = 30;
    //等价于*pa = 30;
    //等价于a = 30;

## 7. 指针数组 ##

指针数组是指针还是数组？

答案：是数组。是存放指针的数组。