指针和引用

weixin_38066782

已于 2023-10-26 16:03:47 修改

阅读量33

点赞数

文章标签：数据结构算法 c语言 c++

于 2023-10-11 18:48:57 首次发布

本文链接：https://blog.csdn.net/weixin_38066782/article/details/133776519

版权

C语言中的指针和引用

语法

指针: 使用*来定义指针变量。

  int *ptr;

引用: C语言本身不支持引用，但C++支持。在C++中，使用&来定义引用。

  int &ref = someVariable;

原理

指针: 指针是一个变量，其值为另一个变量的地址。
引用: 引用是别名，即一个变量的另一个名称。

底层原理

指针: 在内存中有自己的存储空间，存储的是所指向变量的内存地址。
引用: 在编译器层面上，引用并没有实际的存储空间（尽管在某些情况下，编译器可能会为其分配存储空间）。

使用方式

指针

声明与初始化

指针必须在使用前声明。声明的一般形式为 type *pointer_name;。

int *p;  // 声明一个整数指针
int x = 10;
p = &x;  // 初始化指针

专业解析: 在这里，p是一个指向整数的指针。使用&运算符获取变量x的地址，并将其存储在p中。
解引用

使用*运算符来获取指针指向的值。

int y = *p;  // y现在是10

专业解析: *p会返回p指向的内存位置中的值，这里是10。
指针算术

指针支持几种算术运算：增加(++), 减少(--), 加法(+), 和减法(-)。

p++;  // 指向下一个整数位置

专业解析: p++会使p指向下一个整数的内存位置。如果p原来指向地址0x1000，现在会指向0x1004（在大多数系统上，一个整数是4字节）。

引用（仅限C++）

声明与初始化

引用在声明时必须初始化，并且之后不能更改。

int x = 10;
int &ref = x;

专业解析: ref是一个引用，它与x绑定，并且不能重新绑定到另一个变量。
使用引用

引用可以像普通变量一样使用。

ref = 20;  // x现在也是20

专业解析: 修改ref也会修改x，因为它们指向同一块内存。
函数参数

引用常用作函数参数，以避免值传递。

void swap(int &a, int &b) {
    int temp = a;
    a = b;
    b = temp;
}

专业解析: 这个swap函数使用引用参数，因此它会直接修改传入的变量，而不是它们的副本。

经典用例分析

指针

动态内存分配

在C语言中，malloc()和free()函数用于动态内存分配和释放。

int *arr = (int *)malloc(10 * sizeof(int)); // 分配一个包含10个整数的数组
if (arr == NULL) {
    // 内存分配失败
    exit(1);
}
arr[0] = 1; // 使用数组
free(arr);  // 释放内存
arr = NULL; // 置空指针

专业解析: malloc()函数返回一个指向新分配内存块的指针。这里，我们使用类型转换(int *)来确保指针类型的正确性。在使用完毕后，必须调用free()来释放内存，以防止内存泄漏。
数组遍历

指针可以用于数组遍历。

int arr[] = {1, 2, 3, 4, 5};
int *ptr = arr;
for (int i = 0; i < 5; ++i) {
    printf("%d ", *(ptr + i));
}

专业解析: ptr是一个指向数组首元素的指针。通过增加ptr的值，我们可以遍历整个数组。这比使用数组索引更快，因为它避免了多次解引用。
函数参数传递

指针常用于函数参数传递，特别是当你想在函数内部修改参数值时。

void modifyValue(int *x) {
    *x = 10;
}
int main() {
    int a = 5;
    modifyValue(&a);
    printf("%d", a);  // 输出10
    return 0;
}

专业解析: 在这里，modifyValue函数接受一个整数指针作为参数，并修改该指针指向的值。这样，即使在函数调用结束后，这个改变也是持久的。

引用（C++）

函数参数传递

在C++中，引用通常用于函数参数，以避免复制。

void modifyValue(int &x) {
    x = 10;
}
int main() {
    int a = 5;
    modifyValue(a);
    cout << a;  // 输出10
    return 0;
}

专业解析: modifyValue函数接受一个整数引用作为参数，并直接修改它。这避免了参数复制，同时允许我们在函数内部修改参数值。
作为类的成员变量

在C++的类中，引用成员必须在构造函数中初始化。

class MyClass {
private:
    int &ref;
public:
    MyClass(int &x) : ref(x) {}
};

专业解析: 在这里，MyClass有一个整数引用成员ref，它在构造函数中初始化。这是C++中引用成员的标准做法。

注意事项

指针

初始化指针: 始终初始化指针变量。未初始化的指针可能指向随机内存地址，导致未定义行为。

int *ptr = NULL; // 好的做法

空指针检查: 在解引用指针之前，检查它是否为NULL。

if (ptr != NULL) {
    // 安全地解引用指针
}

内存泄漏: 如果你使用malloc()或calloc()分配内存，确保最终使用free()释放它。
悬挂指针: 在释放内存后，确保将指针置为NULL以防止悬挂指针。
数组和指针: 虽然数组名可以作为指针使用，但它们不是完全相同的。数组是常量指针，不能被重新分配。

int arr[10];
int *ptr = arr; // 合法
ptr++;          // 合法
arr++;          // 非法

引用

不可重新绑定: 一旦引用被初始化，就不能改变其绑定的对象。

int x = 10;
int &ref = x;
int y = 20;
ref = y; // 这实际上是改变了x的值，而不是改变ref的绑定

不可为空: 引用必须绑定到一个合法对象，不能像指针那样可以为NULL。

int &ref = NULL; // 非法

必须初始化: 引用在声明时必须被初始化。

int &ref; // 非法

引用的引用: C++不支持引用的引用（但可以有指向指针的指针）。
引用作为函数参数: 使用引用作为函数参数可以实现函数的多重返回，但要注意可能的副作用。

void swap(int &a, int &b) {
    int temp = a;
    a = b;
    b = temp;
}

共同注意事项

类型匹配: 确保指针或引用的类型与其所指对象的类型匹配。
作用域: 注意局部指针或引用在其作用域之外可能不再有效。
const-correctness: 使用const关键字来防止不应该被修改的数据被修改。

const int *ptr;  // 指向常量的指针：名为常量指针
int const *ptr;  // 同上
int *const ptr;  // 指针常量

这些注意事项有助于编写更安全、更健壮的代码。遵循这些最佳实践可以避免许多常见的编程错误和陷阱。

指针和引用的异同点

相同点

间接访问: 无论是指针还是引用，都提供了一种间接访问数据的方式。
可用于函数参数传递: 指针和引用都可以作为函数参数，用于传递非基本类型的数据，以减少数据复制的开销。

不同点

可重新绑定性:

1. **指针**: 可以重新指向另一个对象。
2. **引用**: 一旦绑定到一个对象，就不能重新绑定。

int x = 1, y = 2;
int *ptr = &x;
int &ref = x;

ptr = &y;  // 合法
// ref = y; // 这实际上改变了x的值，而不是让ref重新绑定到y

可空性:

1. **指针**: 可以为`NULL`。
2. **引用**: 必须绑定到一个合法的对象。

int *ptr = NULL;  // 合法
// int &ref = NULL; // 非法

语法:

1. **指针**: 使用`*`和`->`运算符。
2. **引用**: 使用与普通变量相同的语法。

int x = 10;
int *ptr = &x;
int &ref = x;

*ptr = 20;  // 使用*解引用
ref = 20;   // 直接使用

内存占用:
1.
1. 指针: 占用一定的内存，用于存储地址。
2. 引用: 通常不占用额外内存（但这取决于编译器和优化设置）。
初始化:

1. **指针**: 可以在声明后的任何时间初始化。
2. **引用**: 必须在声明时初始化。

int *ptr;  // 合法，但不安全
// int &ref; // 非法

多级间接访问:

1. **指针**: 可以有多级指针（指向指针的指针）。
2. **引用**: 不支持引用的引用。

int **pptr;  // 合法
// int &&ref; // 非法

常量性:

1. **指针**: 可以有指向常量的指针和常量指针。
2. **引用**: 可以有指向常量的引用。

const int *ptr1;  // 指向常量的指针名为常量指针
int const *ptr2;  // 同上
int *const ptr3;  // 指针常量
const int &ref;   // 指向常量的引用

用途:
1.
1. 指针: 更适用于动态内存操作，数组遍历等。
2. 引用: 更适用于函数参数传递，操作符重载等。
通过了解这些异同点，你可以更加明智地选择在特定场景下使用指针还是引用。

指针和引用的使用场景

指针的使用场景

动态内存分配: 当你需要在运行时分配内存时，通常使用指针。

int *arr = (int *)malloc(10 * sizeof(int));

数组操作: 指针用于数组遍历，特别是在C语言中。

for (int *p = arr; p != arr + 10; ++p) {
    // do something
}

多级间接访问: 当需要多级间接访问时，使用指针。

int **pp = &ptr;

数据结构: 在实现链表、树、图等数据结构时，通常使用指针。

struct Node {
    int data;
    struct Node *next;
};

函数指针: 在需要回调函数或者函数表时，使用函数指针。

int add(int a, int b) { return a + b; }
int (*func_ptr)(int, int) = add;

引用的使用场景

函数参数传递: 当你想在函数内部修改参数并反映到外部时，使用引用。

void swap(int &a, int &b) {
    int temp = a;
    a = b;
    b = temp;
}

操作符重载: 在C++中，引用通常用于操作符重载。

Complex operator+(const Complex &a, const Complex &b);

作为类的成员变量: 当类的一个成员变量需要与外部变量共享数据时，可以使用引用。

class MyClass {
    int &ref;
public:
    MyClass(int &r): ref(r) {}
};

范围for循环: 在C++11及以上版本中，使用引用可以避免在范围for循环中复制元素。

for (const auto &elem : vec) {
    // do something
}

代替指针: 在不需要改变所指对象的情况下，引用作为一种更安全、更易于使用的替代品。

void func(const std::string &str) {
    // do something
}

通过了解这些使用场景，你可以更准确地决定在哪种情况下使用指针，以及在哪种情况下使用引用。这有助于你编写更高效、更安全的代码。

附加

回调函数和函数表的理解与使用

为什么使用函数指针作为回调？

使用函数指针作为回调允许你动态地更改被调用的函数，从而提供更大的灵活性。

示例代码

#include <stdio.h>

// 使用typedef定义一个函数指针类型
typedef void (*callback_t)(int);

// 回调函数
void my_callback(int x) {
    printf("Called with %d\n", x);
}

// 接受回调函数的函数
void caller(callback_t callback) {
    callback(42);  // 调用回调函数
}

int main() {
    caller(my_callback);  // 传递回调函数
    return 0;
}

详细解析

定义与概念

回调函数是一种编程模式，它允许一个函数（通常称为“调用者”）在某个特定时间或条件下调用另一个函数（“回调函数”）。这种模式在异步编程、事件驱动编程、插件架构等多种场景中非常有用。

为什么需要回调函数？

解耦合：回调函数可以将一个复杂任务分解为多个更小、更易于管理的部分。
扩展性：通过使用回调，你可以轻松地添加或修改功能，而无需更改现有代码。
动态行为：回调允许在运行时动态地更改程序的行为。

如何使用函数指针实现回调？

在C语言中，函数指针是实现回调的常用方式。函数指针允许你将函数作为参数传递给其他函数，从而实现动态行为。

经典用例：快速排序

假设你要实现一个通用的快速排序算法，该算法可以对任何类型的数组进行排序。你可以使用回调函数来实现这一点。

#include <stdio.h>
#include <stdlib.h>

// 比较函数，用于比较两个整数
int compare(const void *a, const void *b) {
    return (*(int *)a - *(int *)b);
}

int main() {
    int arr[] = {4, 2, 7, 1, 9};
    int size = sizeof(arr) / sizeof(arr[0]);

    // 使用qsort和回调函数进行排序
    qsort(arr, size, sizeof(int), compare);

    // 打印排序后的数组
    for (int i = 0; i < size; ++i) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

在这个例子中，qsort 是一个通用的排序函数，它接受一个比较函数作为其最后一个参数。这个比较函数就是一个回调函数，qsort 会在适当的时候调用它来比较数组中的元素。

注意事项

类型匹配：确保回调函数的签名（参数类型和返回类型）与函数指针匹配。
生命周期：确保回调函数在被调用时仍然有效（即，它没有被释放或越界）。
错误处理：在回调函数中进行必要的错误检查和处理。

总结

回调函数是一种非常强大的编程工具，它提供了一种灵活和可扩展的方式来组织代码。通过使用函数指针，你可以在C语言中实现高度动态的行为。

函数表

函数表是一个包含函数指针的数组或结构，通常用于实现跳转表或者策略模式。

为什么使用函数指针作为函数表？

使用函数指针作为函数表可以让你在运行时动态地选择要执行的函数，这在实现多态行为或者状态机时非常有用。

示例代码

#include <stdio.h>

// 函数声明
void add(int a, int b);
void subtract(int a, int b);

// 函数表
void (*func_table[])(int, int) = {add, subtract};

// 函数定义
void add(int a, int b) {
    printf("Sum: %d\n", a + b);
}

void subtract(int a, int b) {
    printf("Difference: %d\n", a - b);
}

int main() {
    // 使用函数表
    func_table[0](5, 3);  // 输出 "Sum: 8"
    func_table[1](5, 3);  // 输出 "Difference: 2"
    return 0;
}

通过使用函数指针作为回调函数或函数表，你可以编写更灵活、更动态的代码。这两种技术都是C和C++中非常强大的工具。

经典用例1：交通信号灯状态机

一个更经典和全面的例子是模拟交通信号灯的状态机。交通信号灯有三个主要状态：红灯（RED）、黄灯（YELLOW）、绿灯（GREEN）。

状态函数原型

typedef void (*StateFunc)();

各个状态的实现

#include <stdio.h>
#include <unistd.h>  // for sleep()

void red() {
    printf("Red Light: Stop!\n");
    sleep(3);  // 持续3秒
}

void yellow() {
    printf("Yellow Light: Get Ready!\n");
    sleep(1);  // 持续1秒
}

void green() {
    printf("Green Light: Go!\n");
    sleep(2);  // 持续2秒
}

函数表

StateFunc stateTable[] = {red, yellow, green};

主程序

int main() {
    // 当前状态
    int currentState = 0;  // 初始状态：红灯

    // 无限循环模拟信号灯运行
    while (1) {
        // 使用函数表调用相应的状态函数
        stateTable[currentState]();

        // 更新状态
        currentState = (currentState + 1) % 3;
    }

    return 0;
}

在这个例子中，我们使用了一个函数表 stateTable 来存储不同状态的函数指针。然后，我们使用一个无限循环 (while (1)) 来模拟信号灯的持续运行。

注意事项

类型安全：所有状态函数都应具有相同的函数签名。
时间延迟：使用 sleep() 函数来模拟各个状态的持续时间。
状态更新：使用模运算 (%) 来循环更新状态。

经典用例2：简单的计算器状态机（结合Switch-case）

#include <stdio.h>

// 定义状态枚举
typedef enum {
    INIT,           // 初始化状态
    READ_NUM1,      // 读取第一个数字
    READ_OPERATOR,  // 读取操作符
    READ_NUM2,      // 读取第二个数字
    CALCULATE,      // 执行计算
    PRINT_RESULT    // 打印结果
} State;

// 定义状态函数原型
typedef void (*StateFunc)(float *, float *, char *, State *);

// 初始化状态：输出欢迎信息并转到读取第一个数字的状态
void init(float *num1, float *num2, char *op, State *nextState) {
    printf("Calculator started.\n");
    *nextState = READ_NUM1;
}

// 读取第一个数字并转到读取操作符的状态
void readNum1(float *num1, float *num2, char *op, State *nextState) {
    printf("Enter first number: ");
    scanf("%f", num1);
    *nextState = READ_OPERATOR;
}

// 读取操作符并转到读取第二个数字的状态
void readOperator(float *num1, float *num2, char *op, State *nextState) {
    printf("Enter operator (+, -, *, /): ");
    scanf(" %c", op);
    *nextState = READ_NUM2;
}

// 读取第二个数字并转到执行计算的状态
void readNum2(float *num1, float *num2, char *op, State *nextState) {
    printf("Enter second number: ");
    scanf("%f", num2);
    *nextState = CALCULATE;
}

// 执行计算并输出结果，然后转回初始化状态
void calculate(float *num1, float *num2, char *op, State *nextState) {
    float result;
    // 使用switch-case来处理不同的操作符
    switch (*op) {
        case '+':
            result = *num1 + *num2;
            break;
        case '-':
            result = *num1 - *num2;
            break;
        case '*':
            result = *num1 * *num2;
            break;
        case '/':
            if (*num2 != 0) {
                result = *num1 / *num2;
            } else {
                printf("Error: Division by zero.\n");
                *nextState = INIT;
                return;
            }
            break;
        default:
            printf("Error: Invalid operator.\n");
            *nextState = INIT;
            return;
    }
    printf("Result: %f\n", result);
    *nextState = INIT;
}

// 状态函数表
StateFunc stateTable[] = {init, readNum1, readOperator, readNum2, calculate};

// 主函数
int main() {
    State currentState = INIT;  // 初始状态
    float num1, num2;           // 存储数字
    char op;                    // 存储操作符

    // 主循环
    while (1) {
        // 调用当前状态的函数
        stateTable[currentState](&num1, &num2, &op, &currentState);
    }

    return 0;
}