C++的函数指针怎么声明 回调函数与高阶函数实现基础

返回类型 (*指针变量名)(参数类型1, 参数类型2, ...);

int add(int a, int b)

int (*pAdd)(int, int);

#include <iostream>

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

int main() {
    int (*pAdd)(int, int); // 声明函数指针
    pAdd = &add;          // 赋值，&可以省略但通常建议加上以明确意图
    // pAdd = add; // 这样写也行

    int result = pAdd(5, 3); // 通过指针调用函数
    std::cout << "Result: " << result << std::endl; // 输出 8

    return 0;
}

typedef

typedef int (*MathOperation)(int, int); // 定义一个函数指针类型

int subtract(int a, int b) {
    return a - b;
}

int main() {
    MathOperation op = &subtract; // 使用typedef声明并赋值
    std::cout << "Subtract result: " << op(10, 4) << std::endl; // 输出 6
    return 0;
}

auto

decltype

typedef

#include <iostream>
#include <vector>
#include <algorithm> // for std::for_each

// 定义一个回调函数的类型，它接受一个int参数，没有返回值
typedef void (*ProcessItemCallback)(int);

// 这是一个“库函数”，它遍历一个容器，并对每个元素执行回调
void processData(const std::vector<int>& data, ProcessItemCallback callback) {
    std::cout << "开始处理数据..." << std::endl;
    for (int item : data) {
        // 在这里，我们“回调”了用户提供的函数
        callback(item);
    }
    std::cout << "数据处理完毕。" << std::endl;
}

// 用户定义的第一个回调函数：打印两倍的值
void printDouble(int value) {
    std::cout << "  打印两倍: " << value * 2 << std::endl;
}

// 用户定义的第二个回调函数：打印平方
void printSquare(int value) {
    std::cout << "  打印平方: " << value * value << std::endl;
}

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    std::cout << "--- 使用 printDouble 回调 ---" << std::endl;
    processData(numbers, &printDouble); // 传入 printDouble 函数的地址

    std::cout << "\n--- 使用 printSquare 回调 ---" << std::endl;
    processData(numbers, &printSquare); // 传入 printSquare 函数的地址

    // 当然，现代C++中，lambda表达式和std::function通常是更灵活的选择
    // 但其底层思想与函数指针是相通的
    std::cout << "\n--- 使用 Lambda 表达式回调 (现代C++) ---" << std::endl;
    processData(numbers, [](int value) {
        std::cout << "  Lambda处理: " << value + 10 << std::endl;
    });

    return 0;
}

processData

ProcessItemCallback

processData

this

std::function

std::bind

std::sort

#include <iostream>
#include <vector>
#include <algorithm> // 包含 std::sort

// 定义一个比较函数的类型，它接受两个int，返回bool
typedef bool (*CompareFunc)(int, int);

// 这是一个简单的冒泡排序实现，它接受一个比较函数
void bubbleSort(std::vector<int>& arr, CompareFunc compare) {
    int n = arr.size();
    for (int i = 0; i < n - 1; ++i) {
        for (int j = 0; j < n - i - 1; ++j) {
            // 使用传入的比较函数来决定是否交换
            if (compare(arr[j], arr[j+1])) {
                std::swap(arr[j], arr[j+1]);
            }
        }
    }
}

// 升序比较函数
bool ascendingCompare(int a, int b) {
    return a > b; // 如果a大于b，则需要交换，以实现升序
}

// 降序比较函数
bool descendingCompare(int a, int b) {
    return a < b; // 如果a小于b，则需要交换，以实现降序
}

// 打印vector
void printVector(const std::vector<int>& vec) {
    for (int x : vec) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
}

int main() {
    std::vector<int> numbers = {5, 2, 8, 1, 9, 4};

    std::cout << "原始数据: ";
    printVector(numbers);

    std::vector<int> numbers_asc = numbers;
    bubbleSort(numbers_asc, &ascendingCompare); // 传入升序比较函数
    std::cout << "升序排序: ";
    printVector(numbers_asc);

    std::vector<int> numbers_desc = numbers;
    bubbleSort(numbers_desc, &descendingCompare); // 传入降序比较函数
    std::cout << "降序排序: ";
    printVector(numbers_desc);

    // 同样，std::sort 也能接受函数指针，虽然更常用lambda或functor
    std::vector<int> std_sorted = numbers;
    std::sort(std_sorted.begin(), std_sorted.end(), ascendingCompare); // std::sort 也可以直接传入函数名
    std::cout << "std::sort 升序: ";
    printVector(std_sorted);

    return 0;
}

bubbleSort

bubbleSort

CompareFunc

bubbleSort

std::function

const

void (*p)(int)

void func(const int&)

nullptr

// 错误示例：未检查空指针
void (*bad_ptr)(int) = nullptr;
// bad_ptr(10); // 运行时错误！

void (MyClass::*pMemberFunc)(int);

(obj.*pMemberFunc)(arg);

std::function

this

typedef

typedef

using

std::function