你想了解的C/C++指针小结攻略如下：

C/C++指针小结

1. 指针基础

指针是C/C++中一种重要的数据类型，它是用来存储变量地址的变量。

定义指针变量的方式为 类型名* 变量名，例如：

int* ptr;  // 定义一个指向整型变量的指针

获取变量地址的方式为 &变量名，例如：

int a = 10;
int* ptr = &a;  // 将a的地址赋值给ptr

访问指针所指向的变量的方式为 *指针变量名，例如：

int a = 10;
int* ptr = &a;
*ptr = 20;  // 将ptr所指向的变量的值修改为20，此时a的值也被修改为20

2. 指针和数组

指针和数组有着密切的联系，数组名本身就是一个指针，指向数组的首地址。

例如，定义一个包含5个元素的整型数组 arr：

int arr[5] = {1, 2, 3, 4, 5};

可以通过以下两种方式访问数组元素：

int x = arr[2];  // 访问数组arr的第3个元素，即值为3的元素
int y = *(arr + 4);  // 访问数组arr的第5个元素，即值为5的元素

3. 指针和函数

指针和函数有着密切的联系，可以通过指针来传递函数参数，也可以将函数地址赋值给指针。

3.1 指针传参

通过指针传参，可以在函数内部修改外部变量的值，例如：

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

int main()
{
    int x = 1, y = 2;
    swap(&x, &y);  // 将x和y的地址传递给swap函数
    // 此时x的值为2，y的值为1
    return 0;
}

3.2 函数指针

函数指针是指向函数的指针，可以通过函数指针来调用函数。

例如，定义一个返回值为整型，参数为两个整型的函数：

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

可以将该函数的地址赋值给函数指针，例如：

int (*p)(int, int) = add;  // 将add函数的地址赋值给函数指针p
int result = (*p)(1, 2);  // 使用函数指针调用add函数，计算1+2的结果
// 此时result的值为3

4. 指针和动态内存分配

指针还可以用于动态内存分配，可以使用 new 和 delete 关键字来动态分配和释放内存。

例如，动态分配一个包含5个元素的整型数组：

int* ptr = new int[5];  // 动态分配5个整型变量的空间，返回一个指向该空间的指针

使用完后，需要使用 delete 关键字释放内存，例如：

delete[] ptr;  // 释放指向空间的指针ptr所指向的内存空间

5. 示例

5.1 实现二分查找算法

以下是一个使用指针在有序数组中查找指定元素的二分查找算法示例：

#include <iostream>

int* binary_search(int arr[], int size, int target)
{
    int left = 0, right = size - 1;
    while (left <= right) {
        int mid = (left + right) / 2;
        if (arr[mid] == target) {
            // 找到目标元素，返回其地址
            return &arr[mid];
        } else if (arr[mid] > target) {
            // 目标元素在左侧
            right = mid - 1;
        } else {
            // 目标元素在右侧
            left = mid + 1;
        }
    }
    // 未找到目标元素，返回nullptr
    return nullptr;
}

int main()
{
    int arr[] = {1, 2, 3, 4, 5};
    int* ptr = binary_search(arr, 5, 3);
    if (ptr != nullptr) {
        std::cout << "Element found at index " << ptr - arr << std::endl;
    } else {
        std::cout << "Element not found" << std::endl;
    }
    return 0;
}

5.2 实现链表数据结构

以下是一个使用指针实现链表数据结构的示例：

#include <iostream>

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

void printList(ListNode* head)
{
    ListNode* p = head;
    while (p != nullptr) {
        std::cout << p->val << " -> ";
        p = p->next;
    }
    std::cout << std::endl;
}

int main()
{
    // 创建一个包含3个元素的链表
    ListNode* head = new ListNode(1);
    ListNode* node1 = new ListNode(2);
    ListNode* node2 = new ListNode(3);
    head->next = node1;
    node1->next = node2;

    // 遍历并输出链表
    printList(head);

    // 释放链表所占用的内存空间
    while (head != nullptr) {
        ListNode* p = head;
        head = head->next;
        delete p;
    }

    return 0;
}