C语言详解(五) - 指针

怠惰的未禾

发布于 2023-04-27 13:08:17

62800

代码可运行

文章被收录于专栏：Linux之越战越勇Linux之越战越勇

运行总次数：0

代码可运行

1. 指针与内存

1.1 内存

内存是计算机的部件之一，用于暂时存放cpu中的运算数据，以及与硬盘等外部储存器交换数据。
一个内存条中有着许多的储存单元，并且每个储存单元都对应着一个唯一的编号以便与其他储存单元相区分，又叫做内存单元的地址。这些内存单元的编号不变的，即是一个常量。
一个内存单元的大小是一个字节(byte)。

1.2 指针

指针常量：内存中一个最小单元的编号，是一个地址。指针变量：用来存放内存地址的变量，即存放指针常量的变量。指针常量与指针标量在不混淆的情况下可以统称为指针。即指针就是地址。

对于32位机器，有32根地址线，可以产生2^32个地址，每个地址均为一个字节编号，于是可以编址的空间为2^32byte=2^22KB=2^12MB = 2^2GB=4GB

在32为机器上，地址是32个0或1组成的二进制序列，故地址的大小是4字节，那么对应的指针变量的大小便是4字节。

对于64位机器，可以产生2^64个地址，可以编制的空间为2^64byte

在64位机器上，地址是64个0或1组成的二进制序列，故地址的大小是8字节，那么对应的指针变量的大小便是8字节。

2. 指针类型

指针变量可以存放变量的地址。一个问题是不同类型的变量所占字节的大小并不完全相同如char与int，即使所占字节相同如int与float，两者对内存中完全相同的数据所做的处理也有着很大的差别。所以指针变量也需要分为相对应的类型。

2.1 指针变量的定义格式

类型 + * + 变量名

char*	字符指针
int*	整型指针
long int*	长整型指针
float*	单精度浮点型指针
double*	双精度浮点型指针
void*	无类型指针
…

3. 指针的运算

3.1 指针±整数

结果：指针变量前进或后退整数*指针变量所指变量类型所占字节的字节数。

指针前进或后退的距离由指针类型决定

一个例子：

#include <stdio.h>

int main() {
	int a = 10;
	int* pa = &a;
	printf("pa:%p\n", pa);
	pa++;
	printf("pa:%p\n", pa);
	pa--;
	printf("pa:%p\n", pa);

	char c = 'A';
	char* pc = &c;
	printf("pc:%p\n", pc);
	pc++;
	printf("pc:%p\n", pc);
	pc--;
	printf("pc:%p\n", pc);

	return 0;
}

运行截图：

3.2 指针解引用

指针解引用可以访问指针所指向的变量。

**指针类型决定了指针解引用访问的内存的字节数。**同一个变量使用不同类型的指针解引用所访问的字节数不一定相同。例如：

#include <stdio.h>

int main() {
	int a = 0x11111111;
	int b = 0x11111111;
	int *pa = &a;
	char* pc = (char*)&b;

	*pa = 0;
	printf("%x\n", a);

	*pc = 0;
	printf("%x\n", b);

	return 0;
}

运行分析：

3.3 指针 - 指针

同类型的指针之间才能相减。指针-指针的绝对值是两个指针之间的元素个数。注意：不管是不是同类型的指针，指针+指针没有实际意义。

#include <stdio.h>

int main() {
    int arr[10] = { 0 };
    int* p1 = &arr[0];
    int* p2 = &arr[5];
    printf("p2 - p1 = %d\n", p2 - p1);
    printf("p1 - p2 = %d\n", p1 - p2);

    return 0;

运行结果：

//使用两个同类型字符指针相减计算字符串长度
#include <stdio.h>

int my_strlen(char* str);

int main() {
    char str[10] = "sunwukong";
    int len = my_strlen(str);
    printf("%d\n", len);

    return 0;
}

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

3.4 指针的关系运算(比较大小)

#include <stdio.h>

int main(){
    int arr[10] = {0};
    int* p = NULL;
    //指针p虽然指向arr[10],但并未访问到arr[10],没有越界。
    for(p = &arr[10]; p > &arr[0] ; ){
    //指针p先自减1，p再解引用被赋值为1
        *--p = 1;
    }
    
    return 0;
}

注意C语言标准规定：允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但不允许与指向第一个元素之前的那个内存位置的指针比较。

指向数组中某一元素的指针p1，可以与指针p3比较，不可以与p2比较。

4. 野指针

指针指向的位置不可知

4.1 野指针成因

4.1.1 指针未初始化

#include <stdio.h>

int main(){
    int* p;
    *p = 10;
    
    return 0;
}

4.1.2 指针越界访问

#include <stdio.h>

int main(){
    int arr[10] = {0};
    int *p = arr;
    arr[10] = 5;//数组下标越界
    
    return 0;
}

4.1.3 指针指向的空间释放

#include <stdio.h>

int main(){
    int *p = (int*)malloc(sizeof(int));
    free(p);
    *p = 10;
    return 0;
}

4.2 避免野指针

指针初始化
预防指针越界
指针指向空间释放及时置NULL
避免返回局部变量的地址
指针使用之前检查有效性

#include <stdio.h>

int main(){
    int a = 0;
    int *pa = &a;
    if(pa != NULL){
        *pa = 10; 
    }
    printf("%d", *pa);
    
    return 0;
}

5. 指针与数组

5.1 区别与联系

指针是指针，数组是数组。
可以通过指针访问数组的元素

已经知道数组名一般是数组首元素的地址，而指针变量可以存放地址。

对于同一数组便有了不同且等效的表示方式。(但本质相同)

#include <stdio.h>

int main() {
    int arr[10] = { 0 };
    int* p = arr;
    int i = 0;
    int sz = sizeof(arr) / sizeof(arr[0]);
    for (i = 0; i < sz; i++) {
        printf("arr[%d] -> %p-------%p <- (p+%d)\n", i, &arr[i], (p + i), i);
    }
    return 0;
}

运行结果：(p+i)计算的是数组下标为i的元素的地址

#include <stdio.h>

int main(){
    int arr[10] = {0};
    int *p = arr;
    //数组下标法
    int i = 0;
    int sz = sizeof(arr)/sizeof(arr[0]);
    for(i=0; i<sz; i++){
        printf("%d\n", arr[i]);
    }
    //指针偏移量法
    for(i=0; i<sz; i++){
        printf("%d\n", *(p+i));
        //printf("%d\n", *(arr+i));
    }
    return 0;
}

运行截图：

6. 二级指针

指向一级指针的地址的指针变量。

#include <stdio.h>

int main(){
    int a = 10;
    printf("%d\n", a);
    //pa是一个指针，指向的类型是int
    int* pa=&a;
    //对pa解引用访问a
    *pa = 5;
    printf("%d\n", a);
    //ppa是一个指针，指向的类型是int*
    int** ppa = &pa;
    //对ppa第一次解引用访问到pa,再对ppa第二次解引用访问到a
    **ppa = 15;
    printf("%d\n", a);
    
    return 0;
}

运行结果：

7. 指针数组

是一个数组，数组中的每个元素都是指针(即存放指针的数组)。普通数组存放的一般是int/char/double等类型，指针数组存放的是指针也即地址。

#include <stdio.h>

int main() {
    int a = 5;
    int b = 5;
    int c = 5;
    //
    int* parr[5] = { &a, &b, &c };
    int i = 0;
    for (i = 0; i < 3; i++) {
        printf("%d\n", *parr[i]);
    }
    return 0;
}

用指针数组模拟二维数组：

#include <stdio.h>

int main(){
    int a1[4] = {1,2,3,4};
    int a2[4] = {5,6,7,8};
    int a3[4] = {9,10,11,12};
    int* pa[3] = {a1,a2,a3};
    int i = 0;
    for(i=0; i<3; i++){
        int j = 0;
        for(j=0; j<4; j++){
            prinitf("%d ", pa[i][j]);//*(pa[i]+j)
        }
        printf("\n");
    }
    return 0;
}