STL源碼剖析 第七章 仿函數(函數對象)

  • 函數對象：具有函數性質的對象
  • 使得用戶像使用函數一樣使用它
  • 一般函數提供兩個版本，第一個版本使用operator < ;第二版本需要用戶 指定某種操作
  • 第二版本就是設計一個函數，將函數指針作為算法的一個參數；或者將函數操作設計成為一個仿函數，就語言層面是一個class，再以該仿函數產生一個對象，并以此對象作為算法的一個參數
  • 函數指針就可以完成任務，為啥需要引入 函數對象呢？因為函數指針無法滿足STL對抽象性的要求，也無法適配STL的其余組件(適配器)搭配，產生靈活的變化
  • 仿函數就是行為類似函數的對象，為了實現這個功能點，其類別定義中必須自定義(改寫或者重載)function call運算子(operator() )，這樣就可以在函數的對象后面加上一對小括號，以此來調用函數所定義的 operator()?

?分類

  • 操作個數：一元、二元
  • 功能劃分：算法運算、關系運算、邏輯運算

unary_function

  • 用于呈現一元函數的參數型別 和 返回值的型別
//STL規定 每一個Adaptable Unary Function都應該繼承這個型別
template <class Arg,class Result>
struct unary_function{typedef Arg argument_type;typedef Result result_type;
};
  • 某一個仿函數繼承了?unary_function ，其用戶便可以獲取這個仿函數的參數型別
//以下函數繼承了unary_function
template <class T>
struct negate : public unary_function<T,T>{T operator()(const T& x)const {return -x;}
};//以下配接器(adapter) 用來表示某個仿函數的邏輯
template <class Predicate>
class ungry_negate{
public:bool operator()(const typename Predicate::argument_type& x)const{}
};

?binary_function

  • 用于呈現二元函數的第一參數型別、第二參數型別和返回數值型別

//STL規定 每一個Adaptable Binary Function都應該繼承這個型別
template <class Arg1,class Arg2,class Result>
struct binary_function{typedef Arg1 first_argument_type;typedef Arg2 second_argument_type;typedef Result result_type;
};//以下函數繼承了unary_function
template <class T>
struct plus : public binary_function<T,T,T>{T operator()(const T& x,const T&y)const {return x+y;}
};//以下配接器(adapter) 用來將某個二元函數轉化為一元函數
template <class Operation>
class binder1st{
protected:Operation op;typedef typename Operation::first_argument_type value;
public:typename Operation::result_type operator()(const typename Operation::second_argument_type& x)const{}
};

算數類仿函數

  • 加法、減法、乘法、除法、模(余數)、否
  • 除了否是一元函數，其余的都是二元函數
  • 加法? plus<T>
template <class T> struct plus {T operator() (const T& x, const T& y) const {return x+y;}typedef T first_argument_type;typedef T second_argument_type;typedef T result_type;
};
// plus example
#include <iostream>     // std::cout
#include <functional>   // std::plus
#include <algorithm>    // std::transformint main () {int first[]={1,2,3,4,5};int second[]={10,20,30,40,50};int results[5];std::transform (first, first+5, second, results, std::plus<int>());for (int i=0; i<5; i++)std::cout << results[i] << ' ';std::cout << '\n';return 0;
}
  • 減法? minus<T>
template <class T> struct minus {T operator() (const T& x, const T& y) const {return x-y;}typedef T first_argument_type;typedef T second_argument_type;typedef T result_type;
};
// minus example
#include <iostream>     // std::cout
#include <functional>   // std::minus
#include <algorithm>    // std::transformint main () {int numbers[]={10,20,30};int result;result = std::accumulate (numbers, numbers+3, 100, std::minus<int>());std::cout << "The result of 100-10-20-30 is " << result << ".\n";return 0;
}
  • 乘法? multiplies<T>
template <class T> struct multiplies {T operator() (const T& x, const T& y) const {return x*y;}typedef T first_argument_type;typedef T second_argument_type;typedef T result_type;
};

// factorials (multiplies example)
#include <iostream>     // std::cout
#include <functional>   // std::multiplies
#include <numeric>      // std::partial_sumint main () {int numbers[9];int factorials[9];for (int i=0;i<9;i++) numbers[i]=i+1;std::partial_sum (numbers, numbers+9, factorials, std::multiplies<int>());for (int i=0; i<9; i++)std::cout << numbers[i] << "! is " << factorials[i] << '\n';return 0;
}Edit & Run
  • 除法? divides<T>
template <class T> struct divides {T operator() (const T& x, const T& y) const {return x/y;}typedef T first_argument_type;typedef T second_argument_type;typedef T result_type;
};
// divides example
#include <iostream>     // std::cout
#include <functional>   // std::divides
#include <algorithm>    // std::transformint main () {int first[]={10,40,90,40,10};int second[]={1,2,3,4,5};int results[5];std::transform (first, first+5, second, results, std::divides<int>());for (int i=0; i<5; i++)std::cout << results[i] << ' ';std::cout << '\n';return 0;
}
  • 模(余數)? modules<T>
template <class T> struct modulus {T operator() (const T& x, const T& y) const {return x%y;}typedef T first_argument_type;typedef T second_argument_type;typedef T result_type;
};
// modulus example
#include <iostream>     // std::cout
#include <functional>   // std::modulus, std::bind2nd
#include <algorithm>    // std::transformint main () {int numbers[]={1,2,3,4,5};int remainders[5];std::transform (numbers, numbers+5, remainders, std::bind2nd(std::modulus<int>(),2));for (int i=0; i<5; i++)std::cout << numbers[i] << " is " << (remainders[i]==0?"even":"odd") << '\n';return 0;
}
  • 否? negate<T>
template <class T> struct negate {T operator() (const T& x) const {return -x;}typedef T argument_type;typedef T result_type;
};
// negate example
#include <iostream>     // std::cout
#include <functional>   // std::negate
#include <algorithm>    // std::transformint main () {int numbers[]={10,-20,30,-40,50};std::transform (numbers, numbers+5, numbers, std::negate<int>());for (int i=0; i<5; i++)std::cout << numbers[i] << ' ';std::cout << '\n';return 0;
}
  • 可以創建一個指定類型的對象或者產生一個無名的臨時對象來履行對應的函數的功能

證同元素

  • ?即數值A如果和該元素做op運算，會得到A自己
  • 加法的證同元素為0，因為任何元素加上0仍然是他自己
  • 乘法的證同元素是1 ，因為任何元素乘以1仍然是他自己

關系運算類仿函數

  • ?等于 equal_to<T>
template <class T> struct equal_to {bool operator() (const T& x, const T& y) const {return x==y;}typedef T first_argument_type;typedef T second_argument_type;typedef bool result_type;
};// equal_to example
#include <iostream>     // std::cout
#include <utility>      // std::pair
#include <functional>   // std::equal_to
#include <algorithm>    // std::mismatchint main () {std::pair<int*,int*> ptiter;int foo[]={10,20,30,40,50};int bar[]={10,20,40,80,160};ptiter = std::mismatch (foo, foo+5, bar, std::equal_to<int>());std::cout << "First mismatching pair is: " << *ptiter.first;std::cout << " and " << *ptiter.second << '\n';return 0;
}
  • 不等于 not_equal_to<T>
template <class T> struct not_equal_to {bool operator() (const T& x, const T& y) const {return x!=y;}typedef T first_argument_type;typedef T second_argument_type;typedef bool result_type;
};// not_equal_to example
#include <iostream>     // std::cout
#include <functional>   // std::not_equal_to
#include <algorithm>    // std::adjacent_findint main () {int numbers[]={10,10,10,20,20};int* pt = std::adjacent_find (numbers, numbers+5, std::not_equal_to<int>()) +1;std::cout << "The first different element is " << *pt << '\n';return 0;
}
  • 大于 greater<T>
template <class T> struct greater {bool operator() (const T& x, const T& y) const {return x>y;}typedef T first_argument_type;typedef T second_argument_type;typedef bool result_type;
};// greater example
#include <iostream>     // std::cout
#include <functional>   // std::greater
#include <algorithm>    // std::sortint main () {int numbers[]={20,40,50,10,30};std::sort (numbers, numbers+5, std::greater<int>());for (int i=0; i<5; i++)std::cout << numbers[i] << ' ';std::cout << '\n';return 0;
}
  • 大于等于 greater_equal<T>
template <class T> struct greater_equal {bool operator() (const T& x, const T& y) const {return x>=y;}typedef T first_argument_type;typedef T second_argument_type;typedef bool result_type;
};// greater_equal example
#include <iostream>     // std::cout
#include <functional>   // std::greater_equal, std::bind2nd
#include <algorithm>    // std::count_ifint main () {int numbers[]={20,-30,10,-40,0};int cx = std::count_if (numbers, numbers+5, std::bind2nd(std::greater_equal<int>(),0));std::cout << "There are " << cx << " non-negative elements.\n";return 0;
}
  • 小于 less<T>
template <class T> struct less {bool operator() (const T& x, const T& y) const {return x<y;}typedef T first_argument_type;typedef T second_argument_type;typedef bool result_type;
};// less example
#include <iostream>     // std::cout
#include <functional>   // std::less
#include <algorithm>    // std::sort, std::includesint main () {int foo[]={10,20,5,15,25};int bar[]={15,10,20};std::sort (foo, foo+5, std::less<int>());  // 5 10 15 20 25std::sort (bar, bar+3, std::less<int>());  //   10 15 20if (std::includes (foo, foo+5, bar, bar+3, std::less<int>()))std::cout << "foo includes bar.\n";return 0;
}
  • 小于等于 less_equal<T>
template <class T> struct less_equal {bool operator() (const T& x, const T& y) const {return x<=y;}typedef T first_argument_type;typedef T second_argument_type;typedef bool result_type;
};// less_equal example
#include <iostream>     // std::cout
#include <functional>   // std::less_equal, std::bind2nd
#include <algorithm>    // std::count_ifint main () {int numbers[]={25,50,75,100,125};int cx = std::count_if (numbers, numbers+5, std::bind2nd(std::less_equal<int>(),100));std::cout << "There are " << cx << " elements lower than or equal to 100.\n";return 0;
}

邏輯運算類仿函數

  • ?and or Not?
  • and 和 or是二元運算符號 Not是一元符號
  • and? logic_and<T>
template <class T> struct logical_and {bool operator() (const T& x, const T& y) const {return x&&y;}typedef T first_argument_type;typedef T second_argument_type;typedef bool result_type;
};// logical_and example
#include <iostream>     // std::cout, std::boolalpha
#include <functional>   // std::logical_and
#include <algorithm>    // std::transformint main () {bool foo[] = {true,false,true,false};bool bar[] = {true,true,false,false};bool result[4];std::transform (foo, foo+4, bar, result, std::logical_and<bool>());std::cout << std::boolalpha << "Logical AND:\n";for (int i=0; i<4; i++)std::cout << foo[i] << " AND " << bar[i] << " = " << result[i] << "\n";return 0;
}
  • or? ? logic_or<T>
template <class T> struct logical_or {bool operator() (const T& x, const T& y) const {return x||y;}typedef T first_argument_type;typedef T second_argument_type;typedef bool result_type;
};// logical_or example
#include <iostream>     // std::cout, std::boolalpha
#include <functional>   // std::logical_or
#include <algorithm>    // std::transformint main () {bool foo[] = {true,false,true,false};bool bar[] = {true,true,false,false};bool result[4];std::transform (foo, foo+4, bar, result, std::logical_or<bool>());std::cout << std::boolalpha << "Logical OR:\n";for (int i=0; i<4; i++)std::cout << foo[i] << " OR " << bar[i] << " = " << result[i] << "\n";return 0;
}
  • not? ?logical_not<T>
template <class T> struct logical_not {bool operator() (const T& x) const {return !x;}typedef T argument_type;typedef bool result_type;
};// logical_not example
#include <iostream>     // std::cout, std::boolalpha
#include <functional>   // std::logical_not
#include <algorithm>    // std::transformint main () {bool values[] = {true,false};bool result[2];std::transform (values, values+2, result, std::logical_not<bool>());std::cout << std::boolalpha << "Logical NOT:\n";for (int i=0; i<2; i++)std::cout << "NOT " << values[i] << " = " << result[i] << "\n";return 0;
}

證同、選擇、投射

  • 這一章節的仿函數只是將參數原封不動的傳回
  • 其中某些仿函數對傳回的參數有刻意的選擇 、或者刻意的忽略

本文來自互聯網用戶投稿，該文觀點僅代表作者本人，不代表本站立場。本站僅提供信息存儲空間服務，不擁有所有權，不承擔相關法律責任。
如若轉載，請注明出處：http://www.pswp.cn/news/446202.shtml
繁體地址，請注明出處：http://hk.pswp.cn/news/446202.shtml
英文地址，請注明出處：http://en.pswp.cn/news/446202.shtml

如若內容造成侵權/違法違規/事實不符，請聯系多彩編程網進行投訴反饋email:809451989@qq.com，一經查實，立即刪除！

相關文章

開源合同管理系統_「物聯網架構」最適合物聯網的開源數據庫

開源合同管理系統_「物聯網架構」最適合物聯網的開源數據庫

物聯網產生大量的數據&#xff0c;包括流數據、時間序列數據、RFID數據、傳感數據等。要有效地管理這些數據&#xff0c;就需要使用數據庫。物聯網數據的本質需要一種不同類型的數據庫。以下是一些數據庫&#xff0c;當與物聯網一起使用時&#xff0c;會給出非常好的結果。物聯…
閱讀更多...
java 方法重載

java 方法重載

概念 代碼 package lesson.l10_oop;/*** Illustration** author DengQing* version 1.0* datetime 2022/7/1 14:31* function 方法重載*/ public class Load {public static void main(String[] args) {Load load new Load();load.mOL(4);load.mOL(4, 5);load.mOL("ff&qu…
閱讀更多...
STL源碼剖析 第八章 配接器

STL源碼剖析 第八章 配接器

設計模式&#xff1a;將一個類的接口轉化為另外一個類的接口 配接器的概觀和分類 改變仿函數接口 函數配接器 &#xff1b;queue和stack 通過修飾deque函數接口來實現改變容器接口 容器配接器 &#xff1b; insert、reverse、iostream 等iterators他們的接口可以由ite…
閱讀更多...
python中random庫_python標準庫之random模塊

python中random庫_python標準庫之random模塊

Python中的random模塊用于生成隨機數。 下面具體介紹random模塊的功能&#xff1a; 1.random.random() #用于生成一個0到1的 隨機浮點數&#xff1a;0< n < 1.0 1 import random 2 a random.random() 3 print (a)2.random.uniform(a,b) #用于生成一個指定范圍內的隨機符…
閱讀更多...
java 可變個數形參

java 可變個數形參

概念 案例 package lesson.l10_oop;/*** Illustration** author DengQing* version 1.0* datetime 2022/7/1 14:53* function 可變個數形參*/ public class ChangeableFormalParameter {public static void main(String[] args) {ChangeableFormalParameter parameter new Ch…
閱讀更多...
C++標準庫 第七章 STL迭代器

C++標準庫 第七章 STL迭代器

迭代器 能力&#xff1a;行進和存取的能力Input迭代器 一次一個向前讀取元素&#xff0c;按此順序一個一個返回元素例子&#xff1a;從標準輸入裝置(鍵盤) 讀取數據&#xff0c;同一個數據不會被讀取兩次&#xff0c;流水一樣&#xff0c;指向的是邏輯位置使用前置式遞增運算…
閱讀更多...
nacos集群的ap cp切換_阿里Nacos-配置-多環境

nacos集群的ap cp切換_阿里Nacos-配置-多環境

多環境的配置隔離是配置中心最基礎的一個功能之一。不同的環境配置的值不一樣&#xff0c;比如數據庫的信息&#xff0c;業務的配置等。Spring Boot 多環境配置首先我們來回顧下在Spring Boot中用配置文件的方式怎么進行環境的隔離。默認我們都會創建一個application.propertie…
閱讀更多...
java 值傳遞機制

java 值傳遞機制

說明 案例1 案例2 案例3 案例4 案例5 案例6 package lesson.l11_oop2;/*** Illustration** author DengQing* version 1.0* datetime 2022/7/2 21:24* function 將對象作為參數傳遞給方法*/ public class Circle {double radius;public double findArea() {return Math.PI * Ma…
閱讀更多...
密碼學專題 非對稱加密算法指令概述 RSA

密碼學專題 非對稱加密算法指令概述 RSA

非對稱加密算法也稱為公開密鑰算法&#xff0c;其解決了對稱加密算法密鑰需要預分配的難題&#xff0c;使得現代密碼學的研究和應用取得了重大發展。非對稱加密算法的基本特點如下: 加密密鑰和解密密鑰不相同;密鑰對中的一個密鑰可以公開(稱為公開密鑰);根據公開密鑰很難推算出…
閱讀更多...
python元胞自動機模擬交通_結構專欄 | 解析DEFORM軟件中的元胞自動機法

python元胞自動機模擬交通_結構專欄 | 解析DEFORM軟件中的元胞自動機法

點擊上方藍色字體&#xff0c;關注我們導語金屬材料的性能取決于內部的微觀組織結構&#xff0c;而好的材料性能和價格是產品最大的優勢。隨著現代物理冶金、熱成形技術、熱處理技術和計算機技術的興起與發展&#xff0c;使預測和控制金屬材料熱加工過程中的組織演變成為可能。…
閱讀更多...
java 遞歸

java 遞歸

概念 代碼 package lesson.l11_oop2;/*** Illustration** author DengQing* version 1.0* datetime 2022/7/2 21:42* function 遞歸&#xff1a;求n個數的和、乘積*/ public class Recursion {public static void main(String[] args) {Recursion recursion new Recursion();S…
閱讀更多...
密碼學專題 非對稱加密算法指令概述 DH算法指令

密碼學專題 非對稱加密算法指令概述 DH算法指令

DH概述 用于密鑰交換的公開算法&#xff0c;廣泛應用于各種安全協議SSL協議同樣支持DH算法DH算法使用之前需要預先共享兩個參數&#xff0c;本原元g和模n&#xff0c;這兩個參數影響到算法的安全性&#xff0c;因此需要預先生成并檢測其安全性生成這些必要參數和管理這些參數的…
閱讀更多...
java 封裝和隱藏 權限修飾符

java 封裝和隱藏 權限修飾符

概念 問題的引入 封裝性的體現 權限修飾符 案例 package lesson.l11_oop2;/*** Illustration** author DengQing* version 1.0* datetime 2022/7/3 15:28* function*/ public class Person {private int age;public void setAge(int age) { /* if (age<0||age>…
閱讀更多...
if __name__ == __main___python中 __name__ == #x27;__main__#x27; 有什么作用？

if __name__ == __main___python中 __name__ == #x27;__main__#x27; 有什么作用？

python中if __name__ ‘__main__’ 的作用&#xff0c;到底干嘛的&#xff1f;有句話經典的概括了這段代碼的意義&#xff1a;“Make a script both importable and executable”就是讓你寫的腳本模塊既可以導入到別的模塊中用&#xff0c;另外該模塊自己也可執行。這句話&…
閱讀更多...
密碼學專題 非對稱加密算法指令概述 DSA算法指令

密碼學專題 非對稱加密算法指令概述 DSA算法指令

DSA算法和DSA指令概述 DSA算法是美國國家標準的數字簽名算法&#xff0c;只具備數字簽名的功能不具備密鑰交換的功能生成DSA參數然后生成DSA密鑰&#xff0c;DSA參數決定了DSA密鑰的長度三個指令首先是dsaparam指令&#xff0c;該指令主要用來生成DSA密鑰參數&#xff0c;并提…
閱讀更多...
每天定時打開某個網頁_Python科普帖定時通知

每天定時打開某個網頁_Python科普帖定時通知

0 復習上一關我們學習了selenium&#xff0c;它有可視模式與靜默模式這兩種瀏覽器的設置方法&#xff0c;二者各有優勢。然后學習了使用.get(URL)獲取數據&#xff0c;以及解析與提取數據的方法。在這個過程中&#xff0c;我們操作對象的轉換過程&#xff1a;除了上面的方法&am…
閱讀更多...
java 構造器

java 構造器

概念 案例1 package lesson.l11_oop2;/*** Illustration** author DengQing* version 1.0* datetime 2022/7/3 15:28* function*/ public class Person {private int age;private String name;public Person() {this.age 18;}public Person(int age, String name) {this.age …
閱讀更多...
密碼學專題 信息摘要和數字簽名指令

密碼學專題 信息摘要和數字簽名指令

信息摘要 區別于對稱加密和非對稱加密&#xff0c;信息摘要算數是一種不可逆的操作&#xff0c;無論輸入數據的大小輸出的數據長度是固定的信息摘要算數對輸入很敏感&#xff0c;即使數據變化很細微&#xff0c;輸出的結果會出現很大的差異從不同輸入得到相同的輸出的概率非常…
閱讀更多...
dataframe 篩選_Spark.DataFrame與Spark.ML簡介

dataframe 篩選_Spark.DataFrame與Spark.ML簡介

本文是PySpark銷量預測系列第一篇&#xff0c;后面會陸續通過實戰案例詳細介紹PySpark銷量預測流程&#xff0c;包含特征工程、特征篩選、超參搜索、預測算法。在零售銷量預測領域&#xff0c;銷售小票數據動輒上千萬條&#xff0c;這個量級在單機版上進行數據分析/挖掘是非常困…
閱讀更多...
密碼學專題 證書和CA指令 證書和CA功能概述

密碼學專題 證書和CA指令 證書和CA功能概述

為什么需要證書 實現了公鑰和私鑰的相互驗證&#xff0c;但是任何人都可以生成很多的密鑰對&#xff0c;密鑰對并沒有關聯實體身份&#xff0c;因此誕生可數字證書前提是CA是所有用戶都信任的用戶需要將自己的信息和公鑰交給CA進行認證生成一個屬于自己并被其與用戶認可的數字…
閱讀更多...
最新文章

Copyright @ 2022~2023