C++標準庫中的 <functional> 庫是一個強大的工具集，它提供了用于處理函數對象、函數綁定、函數包裝等功能的設施，極大地增強了代碼的靈活性和可復用性。

1. 函數對象（Functors）

函數對象，也被稱作仿函數，是重載了 () 運算符的類的實例。其使用方式與普通函數調用類似，但函數對象可以攜帶狀態(tài)，這使得它比普通函數更加靈活。

#include <iostream>

// 定義一個函數對象類
class Adder {
public:
    int operator()(int a, int b) const {
        return a + b;
    }
};

int main() {
    Adder adder;
    int result = adder(3, 4);
    std::cout << "3 + 4 = " << result << std::endl;
    return 0;
}

• 原理：在 Adder 類中，重載了 () 運算符，該運算符接受兩個 int 類型的參數并返回它們的和。Adder 類的對象 adder 就可以像函數一樣被調用，當調用 adder(3, 4) 時，實際上是調用了 Adder 類的 operator() 方法。
• 優(yōu)點：函數對象可以包含成員變量，這些成員變量可以在對象創(chuàng)建時進行初始化，并且在多次調用 operator() 時保持狀態(tài)，這是普通函數無法做到的。

2.std::function

std::function 是一個通用的多態(tài)函數包裝器，它可以存儲、復制和調用任何可調用對象，包括普通函數、函數指針、成員函數指針、函數對象和 lambda 表達式等。

#include <iostream>
#include <functional>

// 普通函數
int add(int a, int b) {
    return a + b;
}

int main() {
    // 使用 std::function 包裝普通函數
    std::function<int(int, int)> func = add;
    int result = func(3, 4);
    std::cout << "3 + 4 = " << result << std::endl;

    // 包裝 lambda 表達式
    std::function<int(int, int)> lambdaFunc = [](int a, int b) { return a * b; };
    result = lambdaFunc(3, 4);
    std::cout << "3 * 4 = " << result << std::endl;
    return 0;
}

• 模板參數：std::function<int(int, int)> 中的模板參數指定了可調用對象的簽名，即接受兩個 int 類型的參數并返回一個 int 類型的結果。
• 包裝過程：當將普通函數 add 或 lambda 表達式賦值給 std::function 對象時，std::function 會內部存儲該可調用對象，并提供統(tǒng)一的調用接口。當調用 func(3, 4) 或 lambdaFunc(3, 4) 時，std::function 會根據存儲的可調用對象進行相應的調用。
• 用途：std::function 常用于實現(xiàn)回調機制，例如在事件處理、多線程編程等場景中，通過 std::function 可以方便地傳遞和調用不同類型的可調用對象。

3.std::bind

std::bind 用于創(chuàng)建一個新的可調用對象，它將一個可調用對象和其部分或全部參數綁定在一起，允許進行部分參數綁定和參數重排。

#include <iostream>
#include <functional>

// 普通函數
int add(int a, int b) {
    return a + b;
}

int main() {
    // 使用 std::bind 綁定 add 函數的第一個參數為 3
    auto add3 = std::bind(add, 3, std::placeholders::_1);
    int result = add3(4);
    std::cout << "3 + 4 = " << result << std::endl;

    // 參數重排
    auto sub = [](int a, int b) { return a - b; };
    auto reversedSub = std::bind(sub, std::placeholders::_2, std::placeholders::_1);
    result = reversedSub(3, 4);
    std::cout << "4 - 3 = " << result << std::endl;
    return 0;
}

• 部分參數綁定：在 std::bind(add, 3, std::placeholders::_1) 中，add 是要綁定的可調用對象，3 是第一個參數，std::placeholders::_1 是一個占位符，表示新可調用對象的第一個參數。add3 是一個新的可調用對象，當調用 add3(4) 時，實際上是調用 add(3, 4)。
• 參數重排：在 std::bind(sub, std::placeholders::_2, std::placeholders::_1) 中，通過占位符的順序交換了 sub 函數的參數順序。當調用 reversedSub(3, 4) 時，實際上是調用 sub(4, 3)。
• 用途：std::bind 可以用于簡化函數調用，特別是在需要固定部分參數的情況下，或者在需要對參數順序進行調整的情況下。

4.std::mem_fn

std::mem_fn 用于創(chuàng)建一個可調用對象，該對象可以調用類的成員函數。它可以處理成員函數指針，使得調用成員函數更加方便。

#include <iostream>
#include <functional>

class MyClass {
public:
    void print() const {
        std::cout << "Hello, World!" << std::endl;
    }
    int add(int a, int b) const {
        return a + b;
    }
};

int main() {
    MyClass obj;
    // 使用 std::mem_fn 包裝成員函數
    auto printFunc = std::mem_fn(&MyClass::print);
    printFunc(obj);

    auto addFunc = std::mem_fn(&MyClass::add);
    int result = addFunc(obj, 3, 4);
    std::cout << "3 + 4 = " << result << std::endl;
    return 0;
}

• 成員函數指針：&MyClass::print 和 &MyClass::add 是成員函數指針，它們指向 MyClass 類的 print 和 add 成員函數。
• 包裝過程：std::mem_fn 接受成員函數指針作為參數，返回一個可調用對象。當調用 printFunc(obj) 時，std::mem_fn 會將 obj 作為調用 print 成員函數的對象，從而實現(xiàn)成員函數的調用。同樣，addFunc(obj, 3, 4) 會調用 obj 的 add 成員函數，并傳遞 3 和 4 作為參數。
• 用途：std::mem_fn 使得成員函數的調用可以像普通函數調用一樣方便，特別是在需要將成員函數作為參數傳遞給其他函數時非常有用。

5. 預定義的函數對象

<functional> 庫提供了一系列預定義的函數對象，用于常見的操作，如算術運算、比較運算等。

算術運算

#include <iostream>
#include <functional>

int main() {
    std::plus<int> add;
    int result = add(3, 4);
    std::cout << "3 + 4 = " << result << std::endl;

    std::minus<int> sub;
    result = sub(4, 3);
    std::cout << "4 - 3 = " << result << std::endl;
    return 0;
}

• std::plus：std::plus<int> 是一個預定義的函數對象，它重載了 () 運算符，用于執(zhí)行兩個 int 類型數的加法運算。當調用 add(3, 4) 時，實際上是調用了 std::plus<int> 的 operator() 方法，返回 3 + 4 的結果。
• std::minus：std::minus<int> 用于執(zhí)行兩個 int 類型數的減法運算，其原理與 std::plus 類似。

比較運算

#include <iostream>
#include <functional>

int main() {
    std::greater<int> greater;
    bool isGreater = greater(4, 3);
    std::cout << "4 > 3: " << (isGreater ? "true" : "false") << std::endl;

    std::less<int> less;
    isGreater = less(4, 3);
    std::cout << "4 < 3: " << (isGreater ? "true" : "false") << std::endl;
    return 0;
}

• std::greater：std::greater<int> 用于比較兩個 int 類型數的大小，返回 true 表示第一個參數大于第二個參數。當調用 greater(4, 3) 時，返回 true。
• std::less：std::less<int> 用于比較兩個 int 類型數的大小，返回 true 表示第一個參數小于第二個參數。當調用 less(4, 3) 時，返回 false。

6.std::ref和std::cref

std::ref 和 std::cref 用于創(chuàng)建引用包裝器，當需要將引用傳遞給 std::bind 或其他需要按值傳遞參數的地方時非常有用。

#include <iostream>
#include <functional>

void increment(int& num) {
    ++num;
}

int main() {
    int num = 3;
    auto func = std::bind(increment, std::ref(num));
    func();
    std::cout << "num = " << num << std::endl;
    return 0;
}

• std::ref：std::ref(num) 創(chuàng)建了一個對 num 的引用包裝器。在 std::bind(increment, std::ref(num)) 中，由于 increment 函數接受一個引用參數，使用 std::ref 可以確保傳遞給 increment 的是 num 的引用，而不是 num 的副本。當調用 func() 時，increment 函數會修改 num 的值。
• std::cref：std::cref 與 std::ref 類似，但它創(chuàng)建的是一個常量引用包裝器，用于傳遞常量引用。

7.std::hash

std::hash 是一個模板類，用于生成對象的哈希值，常用于實現(xiàn)哈希表等數據結構。

#include <iostream>
#include <functional>

int main() {
    std::hash<int> hasher;
    int num = 3;
    std::size_t hashValue = hasher(num);
    std::cout << "Hash value of " << num << " is " << hashValue << std::endl;
    return 0;
}

• 哈希函數：std::hash<int> 是一個針對 int 類型的哈希函數模板類，它重載了 () 運算符，接受一個 int 類型的參數并返回一個 std::size_t 類型的哈希值。當調用 hasher(num) 時，會根據 num 的值生成一個對應的哈希值。
• 用途：在實現(xiàn)哈希表、哈希集合等數據結構時，std::hash 可以方便地為元素生成哈希值，從而實現(xiàn)快速的查找和插入操作。

8.std::not_fn(C++17 起)

std::not_fn 用于創(chuàng)建一個新的可調用對象，該對象返回原可調用對象結果的邏輯非。

#include <iostream>
#include <functional>
#include <algorithm>
#include <vector>

bool isEven(int num) {
    return num % 2 == 0;
}

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    auto isOdd = std::not_fn(isEven);
    auto oddCount = std::count_if(numbers.begin(), numbers.end(), isOdd);
    std::cout << "Number of odd numbers: " << oddCount << std::endl;
    return 0;
}

• 邏輯非操作：std::not_fn(isEven) 創(chuàng)建了一個新的可調用對象 isOdd，當調用 isOdd 時，它會調用 isEven 并返回其結果的邏輯非。在 std::count_if 中使用 isOdd 可以統(tǒng)計 numbers 向量中奇數的個數。
• 用途：std::not_fn 可以方便地反轉一個布爾函數的邏輯，避免手動編寫反轉邏輯的代碼。

總結

<functional> 庫提供了豐富的工具來處理函數對象和函數調用，通過這些工具可以提高代碼的靈活性和可維護性。合理使用這些工具可以讓代碼更加簡潔和高效，特別是在實現(xiàn)回調機制、函數綁定、成員函數調用等場景中發(fā)揮重要作用。

到此這篇關于C++STL中＜functional＞的具體使用的文章就介紹到這了,更多相關C++STL ＜functional＞內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！