C语言基础-基础指针

文章目录

• 指针
• • 前言
  • 1.什么是指针
  • 2.指针的使用
  • • （1）指针的定义
    • （2）指针的赋值
    • （3）指针类型
    • （4）如何使用指针
  • 3.野指针
  • • （1）导致野指针的原因
    • • ① 未初始化指针
      • ②指针越界访问
      • ③指针指向的空间释放
    • （2）如何避免野指针
    • • ①指针初始化
      • ②小心指针越界
      • ③指针指向空间释放即用null占位
      • ④指针使用之前检查有效性
    • 4.指针运算
    • • 4.1 指针+-整数
      • 4.2 指针-指针
    • 5.指针和数组
    • 6.指针的关系运算
    • • （1）指针数组 && 数组指针
    • 7.二级指针
    • • （1）定义
      • （2）使用
      • （3）总结
    • 8.const修饰指针（一级指针）
    • • 8.1 const 在 * 左边
      • 8.2 const 在 * 右边
    • 9.const修饰指针（二级指针）
    • • 9.1 在**的左边
      • 9.2 在**中间
      • 9.3 在**p的右边
      • 9.4 通过二级指针修改被const修饰的一级指针
  • 总结

指针

前言

在C语言中，指针是非常重要的一个知识点，对于一个C语言的程序员来说，能否熟练的使用指针是非常重要的，也是区别程序员的好坏的一个标准。
注：本内容全部为原创，这是我自己写的笔记

1.什么是指针

指针是编程语言中的一个对象，是将内存的地址赋值给指针变量。

它的值直接指向存在电脑存储器中另一个储存单元

指针其实是地址
地址就是变量
指针就是变量
存放地址的变量

• 指针是用于存放地址的，地址是位移表示一块地址空间的
• 指针的大小在32位平台是4个字节，在64位平台上是8个字节

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

int *p 能够访问4个字节

char *p 能够访问1个字节

double *p 能够访问8个字节

指针类型决定了：指针走一步走多远（指针的步长）

int *p; --> 4

char *p; --> 1

double *p; --> 8

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

2.指针的使用

（1）指针的定义

(指针类型) *(指针名);
//变量方式
(指针类型) *(指针名) = &变量名;
//数组方式
(指针类型) *(指针名) = 数组名;

（2）指针的赋值

指针名 = &变量名;

（3）指针类型

int    *ip;    /* 一个整型的指针 */
double *dp;    /* 一个 double 型的指针 */
float  *fp;    /* 一个浮点型的指针 */
char   *ch;    /* 一个字符型的指针 */

（4）如何使用指针

3.野指针

概念：野指针就是指向的位置不可知的

（1）导致野指针的原因

① 未初始化指针

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

②指针越界访问

    #include <stdio.h>
    int main(){
        int arr[10] = 0;
        int *p = arr;
        for(int i = 0; i <= 11; i++){
            //当指针指向的范围超出数组arr的范围时，p就是野指针
            *(p + i) = 1;
        }
        return 0;
    }

③指针指向的空间释放

在函数内定义了指针，但函数结束后，函数内的所有内容全部释放，指针也被释放了。

（2）如何避免野指针

①指针初始化

②小心指针越界

③指针指向空间释放即用null占位

④指针使用之前检查有效性

    int main(){
        // int a = 10;
        // int *p = &a;//初始化
        // int *pa = NULL;//NULL - 用来初始化指针的，给指针赋值
        int a = 10;
        int *pa = &a;
        *pa = 20;
        pa = NULL;
        if (pa != NULL){
            *pa = 20;
        }
    }

4.指针运算

• 指针±整数
• 指针-指针
• 指针的关系运算

4.1 指针±整数

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

4.2 指针-指针

    int my_strlen(char *str){
        char *start = str;
        char *end = str;
        while (*end != '\0'){
            end++;
        }
        return end - start;
    }
    int main(){
        //strlen - 求字符串长度
        char arr[] = "bit";
        int len = my_strlen(arr);
        printf("%d\n", len);
        return 0;
    }

5.指针和数组

    int main(){
        int arr[10] = {0};
        printf("%p\n", arr);//地址-首元素的地址
        printf("%p\n", &arr[0]);
        printf("%p\n", &arr);//整个数组的地址
        //1.&arr - &数组名不是首元素的地址-数组名表示整个数组 - &数组名 取出的是整个数组的地址
        //2.sizeof(arr) - sizeof(数组名) - 数组名表示的整个数组 - sizeof(数组名)计算的是整个数组的大小
    }

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

6.指针的关系运算

（1）指针数组 && 数组指针

    //指针数组 - 数组 - 存放指针的数组
    //数组指针 - 指针
    int main(){
        int a = 10;
        int b =20;
        int c = 30;
        // int *pa = &a;
        // int *pb = &b;
        // int *pc = &c;
        //整型数组 - 存放整型
        //字符数组 - 存放字符
        //指针数组 - 存放指针
        int *arr[3] = {&a, &b, &c};//指针数组
        for(int i = 0; i < 3; i++){
            printf("%d\n", *(arr[i]));
        }
        return 0;
    }

7.二级指针

（1）定义

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

（2）使用

    int main(){
        int a = 10;
        int *pa = &a;
        int **ppa = &pa;//ppa就是二级指针
        //int ***pppa = &ppa;//pppa是三级指针
        printf("%p\n", pa);
        printf("%p\n", *ppa);
        printf("%d\n", *pa);
        printf("%d\n", **ppa);
        return 0;
    }

（3）总结

    *p = &a;

这句话的意思是将a的地址给p，然后*p得到的是a中的值。

    * *ppa = &pa;

ppa存放的是pa指针中的地址，然后**ppa是pa

8.const修饰指针（一级指针）

通常，我们的指针变量是可以随便使用的，但如果我们想让指针变量或者解引用的指针的内容不改变，那我们就需要使用 const 来修饰指针。

8.1 const 在 * 左边

    int const * p;
    const int* p;

const 在* 左边是修饰 *p的，通过这样修饰后，*p就不能再重新赋值了，*p的值是被固定了，但是指针变量p中的地址是可以重新赋值的。

8.2 const 在 * 右边

    int* const p;

const 在* 右边是修饰 p的，通过这样修饰后，p就不能再重新赋值了，\p的值是被固定了，但是解引用*p中的值是可以重新赋值的。

9.const修饰指针（二级指针）

在二级指针中有三个位置可以加const修饰符

9.1 在**的左边

    const int* *p;
    int const * *p;

const在的左边是修饰p的，但*p和p的值是可以改变的

9.2 在**中间

    int* const *p;

const在的中间是修饰*p的，但p和p的值是可以改变的

9.3 在**p的右边

    int* *const p;

const在的右边是修饰p的，但p和*p的值是可以改变的

9.4 通过二级指针修改被const修饰的一级指针

我们回顾上面讲const修饰符中，别const修饰的变量中的值能被一级指针所修改，那如果别const修改的一级指针能否别二级指针修改呢。

我们来试试：

我们有以下的代码：

    int main(){
        int m = 5, n = 6;
        int* const p = &m;
    }

在这个语句中，const是修饰指针变量p的，所以我们无法对p变量进行修改。（如下图）

但是如果我们通过二级指针来间接修改呢？

如下代码：

    int main(){
    	int m = 5, n = 6;
    	int* const p = &m;
    	int* *pp = ±
    	*pp = &n;
    	printf("%d", *p);
    }

我们声明了一个二级指针，然后给这个二级指针赋值一级指针的地址，然后我们对二级指针变量重新赋n的地址值，然后输出*p里面的内容。

然后运行的结果：

我们可以看到，我们输出*p的结果已经改变，所以可以通过二级指针来修改被const修饰的一级指针的值。但是，这个方法只能在vs中才能运行成功，在dev-C++中就不能成功。如下图：

可以看到这个直接就报错了，无法通过编译。

总结

上面的内容只是指针的基础用法，后面对于指针还有更高级的内容，指针数组和数组指针、指针函数等都在后面指针的进阶说。