Zmyu's Blog

0%

初识指针

发表于
本文字数： 4.1k 阅读时长 ≈ 34 分钟
文章时效性提示

本文发布于 515 天前，部分信息可能已经改变，请注意甄别。

指针是什么？

指针就是一个变量，变量里存着地址，就是通过它可以找到对应的内存单元。
也就是说：指针就是地址，地址就是指针。

1
2
int a = 10;
int* p = &a;//指针变量

int* p = &a;这里我们对变量a，取出它的地址，可以使用&操作符。
将a的地址存在变量p中，p就是一个指针变量。
存放在指针中的值都被当成地址处理。

指针类型决定了进行解引用操作时能访问的空间大小
int* p能访问4字节
char* p能访问1字节
double* p能访问8字节
指针类型要根据需要，选择合适的。

指针+-整数

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
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;
}

打印的结果是：

1
2
3
4
0x16fdff2a8
0x16fdff2ac
0x16fdff2a8
0x16fdff2a9

pa是整型，加1跳过4个字节。
pc是字符型，加1跳过1个字节。
指针类型决定了：指针走一步走多远（指针的步长），单位是字节

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
int main() {
    int arr[10] = {0};
    int* p = arr;//数组名-首元素地址,创建的指针变量p，存放了数组中第一个元素地址。
    int i = 0;
    for (i=0; i<10; i++) {
        *(p+i) = 1;
    }//把数组中每个元素都改成了1
    return 0;
}

野指针

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

野指针原因

1、指针未初始化

1
2
3
4
    int a;//局部变量不初始化，默认是随机值。
    int* p;//局部的指针变量，就被初始化随机值。
    *p = 20;
}

2、指针越界访问

1
2
3
4
5
6
7
    int arr[10] = {0};
    int *p = arr;
    int i = 0;
    for (i=0; i<12; i++) 
    {
        p++;//越出了数组范围
    }

3、指针指向的空间释放了

1
2
3
4
5
6
7
8
9
10
int* test()
{
	int a = 10;
	return &a;
}
int main()
{
	int *p = test();
	*p = 20;//地址指向的空间已经释放了。
}

如何避免野指针？

  • 指针要初始化
  • 小心指针越界
  • 指针指向空间释放即使置NULL-不知道给什么值就给NULL
  • 指针使用之前检查有效性

指针运算

  • 指针+-整数
  • 指针-指针
  • 指针的关系运算
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    #include <stdio.h>
    int main() {
        int arr[10] = {1,2,3,4,5,6,7,8,9,10};
        int i = 0;
        int sz = sizeof(arr)/sizeof(arr[0]);
        int* p = arr;
        for (i=0; i<sz; i++) {
            printf("%d ",*p);
            p = p + 1;
        }
        return 0;
    }
1
2
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    printf("%d\n",&arr[9] - &arr[0]);

打印的结果是9。由此知，指针-指针，得到的结果是中间元素的个数。
警告⚠️：不可以让两个不同的指针相减。

模拟实现strlen效果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
int my_strlen(char* str)
{
    int i = 0;
    char* start = str;
    char* end = str;
    while (*end != '\0') {
        end++;
    }
    return end - start;
}

int main() {
    char arr[] = "bit";
    int len = my_strlen(arr);
    printf("%d\n",len);
    return 0;
}
1
2
3
4
5
6
7
#define N_VALUES 5
float values[N_VALUES];
float *vp;
for(vp = &values[N_VALUES]; vp>&values[0] ; )
{
	*--vp = 0;
}

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

指针和数组

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

打印的结果是一致的，可以认为arr就是数组首元素的地址。即arr和&arr[0]是一致的。
但是有2个例外：

  • &arr - &数组名 - 不是首元素地址- 数组名表示整个数组 - 取出的是整个数组的地址。（但是打印出来的结果还是首元素地址）
  • sizeof内部 - sizeof(arr) - sizeof(数组名) - 表示整个数组的大小。
1
2
3
4
    int arr[10] = {0};
    printf("%p\n",arr+1);
    printf("%p\n",&arr[0]+1);
    printf("%p\n",&arr+1);

打印的结果是：

1
2
3
0x16fdff284
0x16fdff284
0x16fdff2a8

上面的结果可知，&arr取出的是整个数组的地址。

数组可以通过指针访问

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

打印的结果是：

1
2
3
4
5
6
7
8
9
10
0x16fdff280  =====  0x16fdff280
0x16fdff284  =====  0x16fdff284
0x16fdff288  =====  0x16fdff288
0x16fdff28c  =====  0x16fdff28c
0x16fdff290  =====  0x16fdff290
0x16fdff294  =====  0x16fdff294
0x16fdff298  =====  0x16fdff298
0x16fdff29c  =====  0x16fdff29c
0x16fdff2a0  =====  0x16fdff2a0
0x16fdff2a4  =====  0x16fdff2a4
1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
int main() {
    int arr[10] = {0};
    int* p = arr;
    int i = 0;
    for (i = 0;i<10; i++) {
        *(p+i) = i;
    }
    for (i = 0;i<10; i++) {
        printf("%d\n",arr[i]);
    }
}

二级指针

1
2
3
4
5
6
7
8
#include <stdio.h>
int main() {
    int a = 10;
    int* pa = &a;//pa就是一级指针变量，int*就是一级指针类型
    int** ppa = &pa;//ppa就是二级指针变量，int**就是二级指针类型
    int*** pppa = &ppa; //三级指针
    return** 0;
}

int** ppa = &pa; ppa就是二级指针变量，int**就是二级指针类型
int**中后面的*代表是个指针变量，指向int*这个指针

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
int main() {
    int a = 10;
    int* pa = &a;//pa就是一级指针变量，int*就是一级指针类型
    int** ppa = &pa;//ppa就是二级指针变量，int**就是二级指针类型
    printf("%d\n",**ppa);
    **ppa = 20;//通过二级指针修改a的值
    printf("%d\n",**ppa);
    return 0;
}

打印的结果是10和20

指针数组

  • 指针数组 本质是数组 - 存放指针的数组

  • 数组指针 本质是指针

  • 整型数组 - 存放整型

  • 字符数组 - 存放字符

  • 指针数组 - 存放指针

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    #include <stdio.h>
    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};//指针数组
        int i = 0;
        for (i = 0; i<3; i++) 
        {
            printf("%d ",*(arr[i]));
        }
    }

    打印的结果是10 20 30