深入理解C指针

​#C语言 #​ #C指针 #​

1 认识指针

指针：一个存放内存地址的变量

1.1 指针和内存

​​

‍

阅读指针声明时候，可以选择倒过来读，会更容易理解。

指针被赋值为NULL时候，会被解释为二进制0.

void指针
具有和char指针相同的形式和内存对齐方式。
只能用作数据指针，不能用作函数指针。

‍

全局指针和静态指针在程序启动时候被初始化为NULL。

1.2 指针的类型和长度

size_t类型是无符号整数，经常用于循环计数器、数组索引等。

在部分for循环中 如果中间的判断条件为 size_t a >= 0​，则可能会出错，该循环不会停止

例如 for (szie_t i = n; i >= 0; i--) {...}​, 当i为零时，由于是无符号整数，再减1还为整数，所以一直循环。（如果希望使用size_t 中间判断可以改为 ​i != SIZE_MAX​）

‍

指针的长度可以通过sizeof​操作符判断

‍

1.3 指针操作符

‍

​​

‍

1.3.1 指针算数运算

• 指针加上/减去整数
  给指针加上⼀个整数实际上加的数是这个整数和指针数据类型对应字节数的乘积。
• 两个指针相减
  通常是判断数组中的元素顺序
• 比较指针
  判断数组元素的相对顺序

‍

数组的名字，返回的只是数组地址，也就是数组第⼀个元素的地址。

1.4 指针的常见用法

1.4.1 多次间接引用

例如传统的argv 和argc 参数来给main 函数传递程序参数

俗称指针的指针

1.4.2 常量与指针

1、可以将指针定义为指向常量，这意味着不能通过指针修改它所引⽤的值。

​const int *p​; 不可以修改p指向的值，但是可以更改p的指向，让它指向其他值

​int const *p​和const int *p​ 是等价的

• pci 可以被修改为指向不同的整数常量；

• pci 可以被修改为指向不同的⾮整数常量；

• 可以解引pci 以读取数据；

• 不能解引pci 从⽽修改它指向的数据。

  ‍

2、指向非常量的常量指针

意味着指针不可以变，但是指向的数据可以变(因此如果指向const定义的一些非指针变量会出错)

例如int *const cpi = ...

• cpi 必须被初始化为指向 ⾮ 常量变量；

• cpi 不能被修改；

• cpi 指向的数据可以被修改。

  ‍

3、指向常量的常量指针

不可以修改指针、不可以修改指针指向的数据

‍

4、指向”指向常量的常量指针“的指针

下面第二行为指向”指向常量的常量指针“的指针

const int * const cpci = &limit;
const int * const * pcpci;

‍

2 C的动态内存管理

2.2 动态内存分配函数

stdlib.h​​

‍

malloc

void* malloc(size_t);

如果内存不足，返回NULL，此外新分配的内存会包含垃圾数据。

calloc
分配内存同时清空内存，也即设置为二进制0

void *calloc(size_t numElements, size_t elementSize);

realloc

​​

‍

alloca

函数返回后会自动释放内存，但是要求系统运行是基于栈

‍

c99中引入了可变长数组

char* buf[size];

‍

2.3 free

void free(void *ptr);

如果传入空指针，则什么都不做

‍

2.5 动态内存分配技术

资源获取即初始化

GNU的扩展要⽤到RAII_VARIABLE 宏，它声明⼀个变量，然后给变量关联如

下属性：
⼀个类型；
创建变量时执⾏的函数；
变量超出作⽤域时执⾏的函数

#define RAII_VARIABLE(vartype,varname,initval,dtor) \

void *dtor* ## varname (vartype * v) { dtor(*v); } \

vartype varname _*attribute__((cleanup(_dtor* ## varname))) =

(initval)


void raiiExample() {
    RAII_VARIABLE(char*, name, (char*)malloc(32), free);
    strcpy(name,"RAII Example");
    printf("%s\n",name);
}

3 指针和函数

3.1 程序的栈和堆

程序栈是支持函数执行的内存区域，通常和堆共享。
程序栈在这个区域的下部，堆是上部。

程序栈存放栈帧 (stack frame) ，栈帧存放函数参数和局部变量。

栈帧： 组成

• 返回地址：函数完成后要返回的程序内部地址。

• 局部数据存储：为局部变量分配的内存。

• 参数存储：为函数参数分配的内存。

• 栈指针和基指针：运⾏时系统⽤来管理栈的指针。

栈指针通常指向栈顶部。基指针（帧指针）通常存在并指向栈帧内部的地

址，⽐如返回地址，⽤来协助访问栈帧内部的元素。这两个指针都不是C指

针，它们是运⾏时系统管理程序栈的地址。

‍

样例

float average(int *arr, int size) {
    int sum;
    printf("arr: %p\n",&arr);
    printf("size: %p\n",&size);
    printf("sum: %p\n",&sum);
    for(int i=0; i<size; i++) {
        sum += arr[i];
    }
    return (sum * 1.0f) / size;
}

arr: 0x500
size: 0x504
sum: 0x480

参数地址和局部变量地址之间的空档，保存的是运⾏时系统管理栈所需要的
其他栈帧元素。

系统在创建栈帧时，将参数以跟声明时相反的顺序推到帧上，最后推⼊局部变量，如图所⽰。在这个例⼦中，arr 在size之后被推⼊。通常，接下来会推⼊函数调⽤的返回地址，然后是局部变量。推⼊它们的顺序跟其在代码中列出的顺序相反。

​​

‍

3.2 通过指针传递和返回数据

传递指向常量的指针是C中常⽤的技术，效率很⾼，因为我们只传了数据的地址，能避免某些情况下复制⼤量内存。不过，如果只是传递指针，数据就能被修改。如果不希望数据被修改，就要传递指向常量的指针。

‍

实现自己的free函数

#define safeFree(p) saferFree((void**)&(p))

void saferFree(void **pp) {
    if (pp != NULL && *pp != NULL) {
        free(*pp);
        *pp = NULL;
    }
}

用法：

int main() {
    int *pi;
    pi = (int*) malloc(sizeof(int));
    *pi = 5;
    printf("Before: %p\n",pi);
    safeFree(pi);
    printf("After: %p\n",pi);
    safeFree(pi);
    return (EXIT_SUCCESS);
}

第⼆次调⽤safeFree 宏给它传递NULL 值不会导致程序终⽌，因为saferFree 函数检测到这种情况并忽略了这个操作。

‍

3.3 函数指针

顾虑：处理器可能无法配置流水线作分支预测

3.3.1 声明函数指针

‍

​​

3.3.2 使用函数指针

‍

#include <stdio.h>
#include <malloc.h>

int (*fptr1)(int);
int square(int num) {
    return num * num;
}

int main() {
    int n = 5;
    fptr1 = square; // fptr1 = &square
    printf("Hello, World! %d\n", fptr1(n));
    return 0;
}

输出

Hello, World! 25

‍

​​

‍

有时候可以为函数指针声明一个类型定义
​typedef int (*funcptr)(int);​

#include <stdio.h>
#include <malloc.h>

typedef int (*funcptr)(int);
int square(int num) {
    return num * num;
}

int main() {
    int n = 5;
    funcptr fptr1;
    fptr1 = &square;
    printf("Hello, World! %d\n", fptr1(n));
    return 0;
}

3.3.3 传递函数指针

简单例子

int add(int num1, int num2) {
    return num1 + num2;
}

int sub(int num1, int num2) {
    return num1 - num2;
}

typedef int (*fptrOperator)(int, int);

int compute(fptrOperator operator, int num1, int num2) {
    return operator(num1, num2);
}

void test_compute() {
    printf("%d\n",compute(add, 5, 6));
    printf("%d\n",compute(sub, 5, 6));

}

输出
11
-1

‍

3.3.4 返回函数指针

使用一个函数，基于输入的字符返回相应的函数指针。

fptrOperation select(char opcode) {
    switch(opcode) {
        case '+': return add;
        case '-': return subtract;
    }
}

int evaluate(char opcode, int num1, int num2) {
    fptrOperation operation = select(opcode);
    return operation(num1, num2);
}

printf("%d\n",evaluate('+', 5, 6));
printf("%d\n",evaluate('-', 5, 6));

3.3.5 使用函数指针数组

函数指针数组可以基于某些条件选择要执⾏的函数

typedef int (*operation)(int, int);
operation operations[128] = {NULL};
// 或
int (*operations[128])(int, int) = {NULL};

// 数组赋值
void initializeOperationsArray() {
    operations['+'] = add;
    operations['-'] = subtract;
}

int evaluateArray(char opcode, int num1, int num2) {
    fptrOperation operation;
    operation = operations[opcode]; // 数组函数指针选择
    return operation(num1, num2);
}

3.3.6 比较函数指针

add 函数被赋给fptr1 函数指针，然后和add 函数的地址做⽐较

fptrOperation fptr1 = add;
if(fptr1 == add) {
    printf("fptr1 points to add function\n");
} else {
    printf("fptr1 does not point to add function\n");
}

主要是可以方便部分情况下动态修改操作

3.3.7 转换函数指针

可以将指向某个函数的指针转换为其他类型的指针

‍

4 指针和数组

4.1 数组概述

4.1.1 一维数组

一维数组是线性结构，用索引访问成员，由于c语言没有强制规定边界，无效索引会造成不可预期的行为。
​int vector[5]​

数组的内部表⽰不包含其元素数量的信息，数组名字只是引⽤了⼀块内存。对数组做sizeof 操作会得到为该数组分配的字节数，要知道元素的数量，只需将数组长度除以元素长度，如下所⽰，打印结果是5：​printf("%d\n", sizeof(vector)/sizeof(int));​

‍

4.1.2 二维数组

需要程序把二位数组映射到一维，也即先把数组的第一行放进内存，接着是第二行。。

4.2 指针表示法和数组

pv[i] 等价于 *(pv + i)

⽅括号表⽰法会取出pv 中包含的地址，⽤指针算术运算把索引i 加上，然后解引新地址返回其内容。

‍

数组和指针的差别

int vector[5] = {1, 2, 3, 4, 5};
int *pv = vector;

vector[i] ⽣成的代码和*(vector+i) ⽣成的不⼀样，vector[i] 表⽰法⽣成的机器码从位置vector 开始，移动i 个位置，取出内容。⽽*(vector+i) 表⽰法⽣成的机器码则是从vector 开始，在地址上增加i ，然后取出这个地址中的内容。尽管结果是⼀样的，⽣成的机器码却不⼀样

‍

sizeof 操作符对数组和同⼀个数组的指针操作也是不同的。对vector 调⽤sizeof 操作符会返回20，就是这个数组分配的字节数。

4.3 malloc创建一维数组

int *pv = (int*) malloc(5 * sizeof(int));
for(int i=0; i<5; i++) {
    pv[i] = i+1;
}
//或者
for(int i=0; i<5; i++) {
    *(pv+i) = i+1;
}

警告 在上个例⼦中我们⽤的是 (pv+i) ⽽不是pv+i ，因为解引操作符的优先级⽐加操作符⾼，先解引第⼆个表达式的指针，得到指针所引⽤的值，然后再给这个整数加上i 。这不是我们要的效果，⽽且，如果我们把这个表达式作为左值，编译器会抱怨。所以，为了让代码正确⼯作，我们需要强制先做加法，然后才是解引操作。