C++中各种可调用对象深入讲解

C++中可调用对象的深入讲解

什么是可调用对象？

在C++中，可调用对象是指可以被调用、执行的实体。常见的可调用对象包括函数、类成员函数、lambda表达式等。C++中的可调用对象都可以作为函数参数或返回值进行传递。

函数指针作为可调用对象

在C++中，函数指针也是可调用对象之一。定义函数指针的方式如下：

int (*funcPtr)(int, int); // 定义一个返回值为int，参数为两个int的函数指针

函数指针可以像函数一样被调用，例如：

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

int (*funcPtr)(int, int) = add; // 将函数add的地址赋值给函数指针
int result = funcPtr(1, 2); // 调用函数指针

std::function作为可调用对象

std::function是C++11中的一个函数对象包装器，它可以包裹任何可调用对象，包括函数指针、函数对象、lambda表达式等。

std::function的定义形式如下：

std::function<返回值类型(参数类型1, 参数类型2, ...)> 函数名;

例如：

#include <functional>
#include <iostream>

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

class A {
public:
    int memberFunc(int a, int b) {
        return a + b;
    }
};

int main() {
    std::function<int(int, int)> funcPtr = add; // 函数指针作为可调用对象
    std::cout << funcPtr(1, 2) << std::endl;

    A a;
    std::function<int(A&, int, int)> memberFuncPtr = &A::memberFunc; // 类成员函数指针作为可调用对象
    std::cout << memberFuncPtr(a, 1, 2) << std::endl;

    auto lambdaExpr = [](int a, int b) { return a + b; }; // lambda表达式作为可调用对象
    std::function<int(int, int)> lambdaPtr = lambdaExpr;
    std::cout << lambdaPtr(1, 2) << std::endl;

    return 0;
}

可调用对象作为函数参数和返回值

可调用对象可以作为函数的参数和返回值进行传递。例如：

#include <functional>
#include <iostream>

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

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

int calculate(std::function<int(int, int)> funcPtr, int a, int b) {
    return funcPtr(a, b);
}

std::function<int(int, int)> getFuncPtr(bool addOrSub) {
    if (addOrSub) {
        return add;
    } else {
        return sub;
    }
}

int main() {
    std::function<int(int, int)> addPtr = add;
    int result1 = calculate(addPtr, 1, 2);
    std::cout << result1 << std::endl;

    std::function<int(int, int)> subPtr = sub;
    int result2 = calculate(subPtr, 1, 2);
    std::cout << result2 << std::endl;

    std::function<int(int, int)> funcPtr1 = getFuncPtr(true);
    int result3 = funcPtr1(1, 2);
    std::cout << result3 << std::endl;

    std::function<int(int, int)> funcPtr2 = getFuncPtr(false);
    int result4 = funcPtr2(2, 1);
    std::cout << result4 << std::endl;

    return 0;
}

示例说明

示例1：使用类成员函数指针作为可调用对象

在示例代码中，定义了一个类A和一个成员函数memberFunc。我们使用std::function包裹类成员函数指针，将其作为可调用对象进行传递，并在main函数中进行了调用。

#include <functional>
#include <iostream>

class A {
public:
    int memberFunc(int a, int b) {
        return a + b;
    }
};

int main() {
    A a;
    std::function<int(A&, int, int)> memberFuncPtr = &A::memberFunc; // 类成员函数指针作为可调用对象
    std::cout << memberFuncPtr(a, 1, 2) << std::endl;

    return 0;
}

示例2：使用可调用对象作为函数参数和返回值

在示例代码中，定义了两个函数add和sub，以及一个calculate函数用于对可调用对象进行调用。在main函数中，我们使用可调用对象作为函数的参数和返回值，并进行了不同情况下的调用。

#include <functional>
#include <iostream>

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

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

int calculate(std::function<int(int, int)> funcPtr, int a, int b) {
    return funcPtr(a, b);
}

std::function<int(int, int)> getFuncPtr(bool addOrSub) {
    if (addOrSub) {
        return add;
    } else {
        return sub;
    }
}

int main() {
    std::function<int(int, int)> addPtr = add;
    int result1 = calculate(addPtr, 1, 2);
    std::cout << result1 << std::endl;

    std::function<int(int, int)> subPtr = sub;
    int result2 = calculate(subPtr, 1, 2);
    std::cout << result2 << std::endl;

    std::function<int(int, int)> funcPtr1 = getFuncPtr(true);
    int result3 = funcPtr1(1, 2);
    std::cout << result3 << std::endl;

    std::function<int(int, int)> funcPtr2 = getFuncPtr(false);
    int result4 = funcPtr2(2, 1);
    std::cout << result4 << std::endl;

    return 0;
}