C++的operator()怎么使用

這篇文章主要介紹“C++的operator()怎么使用”，在日常操作中，相信很多人在C++的operator()怎么使用問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”C++的operator()怎么使用”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！

在C++語言中有時候需要重載運算符: ()，今天我們主要介紹它主要應用的場合。

仿函數
先考慮一個簡單的例子：假設有一個vector，你的任務是統計長度小于5的string的個數，如果使用count_if函數的話，你的代碼可能長成這樣：

 bool LengthIsLessThanFive(const string& str) {
      return str.length() < 5;    
 }
 int res = std::count_if(vec.begin(), vec.end(), LengthIsLessThanFive);

其中count_if函數的第三個參數是一個函數指針，返回一個bool類型的值。一般的，如果需要將特定的閾值長度也傳入的話，我們可能將函數寫成這樣：

 bool LenthIsLessThan(const string& str, int len) {
     return str.length()<len;
 }

這個函數看起來比前面一個版本更具有一般性，但是他不能滿足count_if函數的參數要求：count_if要求的是unary function（僅帶有一個參數）作為它的最后一個參數。所以問題來了，怎么樣找到以上兩個函數的一個折中的解決方案呢？

這個問題其實可以歸結于一個data flow的問題，要設計這樣一個函數，使其能夠access這個特定的length值，回顧我們已有的知識，有2種解決方案可以考慮：

函數的參數：
這種方法我們已經討論過了，多個參數不適用于count_if函數；

全局變量：
我們可以將長度閾值設置成一個全局變量，代碼可能像這樣：

  int maxLength;
  bool LengthIsLessThan(const string& str) {
      return str.length() < maxLength;
  }
  int res = std::count_if(vec.begiin(), vec.end(), LengthIsLessThan);

這段代碼看似很不錯，實則不符合規范，剛重要的是，它不優雅。原因有以下幾點要考慮：

容易出錯：
為什么這么說呢，我們必須先初始化maxLength的值，才能繼續接下來的工作，如果我們忘了，則可能無法得到正確答案。此外，變量maxLength和函數LengthIsLessThan之間是沒有必然聯系的，編譯器無法確定在調用該函數前是否將變量初始化，給碼農平添負擔；
沒有可拓展性：
如果我們每遇到一個類似的問題就新建一個全局變量，尤其是多人合作寫代碼時，很容易引起命名空間污染（namespace polution）的問題；當范圍域內有多個變量時，我們用到的可能不是我們想要的那個；
全局變量的問題：
每當新建一個全局變量，即使是為了coding的便利，我們也要知道我們應該盡可能的少使用全局變量，因為它的cost很高；而且可能暗示你這里有一些待解決的優化方案。
說了這么多，還是要回到我們原始的那個問題，有什么解決方案呢？答案當然就是這篇文章的主題部分：仿函數。我們的初衷是想設計一個unary function，使其能做binary function的工作，這看起來并不容易，但是仿函數能解決這個問題。

先來看仿函數的通俗定義：仿函數（functor）又稱為函數對象（function object）是一個能行使函數功能的類。仿函數的語法幾乎和我們普通的函數調用一樣，不過作為仿函數的類，都必須重載operator()運算符，舉個例子：

 class Func{
     public:
         void operator() (const string& str) const {
             cout<<str<<endl;
         }
 };
 Func myFunc;
 myFunc("helloworld!");
 output: helloworld!

仿函數其實是上述解決方案中的第3種方案：成員變量。成員函數可以很自然的訪問成員變量：

 class StringAppend{
      public:
          explicit StringAppend(const string& str) : ss(str){}
  
          void operator() (const string& str) const{
               cout<<str<<' '<<ss<<endl;
          }
      
      private:
         const string ss;  
 };
 
 StringAppend myFunc("is world");
 myFunc("hello");
 output: hellois world

我相信這個例子能讓你體會到一點點仿函數的作用了；它既能想普通函數一樣傳入給定數量的參數，還能存儲或者處理更多我們需要的有用信息。

讓我們回到count_if的問題中去，是不是覺得問題變得豁然開朗了？

 class ShorterThan {
     public:
         explicit ShorterThan(int maxLength) : length(maxLength) {}
         bool operator() (const string& str) const {
             return str.length() < length;
         }
     private:
         const int length;
 };

count_if(myVector.begin(), myVector.end(), ShorterThan(length)); //直接調用即可
這里需要注意的是，不要糾結于語法問題：ShorterThan(length)似乎并沒有調用operator()函數？其實它調用了，創建了一個臨時對象。你也可以自己加一些輸出語句看一看。

類型轉換
C++中可以定義類型轉換函數，將類對象轉換為其他類型，函數原型為：operator Type()

類型轉換函數與轉換構造函數具有同等的地位；
類型轉換函數使得編譯器有能力將對象轉化為其他類型；
編譯器能夠隱式的使用類型轉換函數；
轉換為普通數據類型
    #include <iostream>
    #include <string>
    using namespace std;
    class Test
    {
       
    public:
        Test(int i = 0)
        {
            mValue = i;
        }
        int value()
        {
            return mValue;
        }
        operator int ()
        {
            return mValue;
        }
        
    private:
           int mValue;
    };
    
    int main()
    {   
        Test t(100);
        int i = t;
    
        cout << "t.value() = " << t.value() << endl;
        cout << "i = " << i << endl;
    
        return 0;
    }

類類型之間的轉換
#include <iostream>
#include <string>

class Test;

class Value
{
public:
    Value()
    {

    }

    Value(Test& t) // false
    // explicit Value(Test& t) // Ok
    {
        std::cout << "explicit Value(Test& t)" << std::endl;                                        
    }            
};

class Test
{
    int mValue;

public:
    Test(int i = 0)
    {
        mValue = i;                                
    }

    int value()
    {
        return mValue;                                    
    }

    operator Value()
    {
        Value ret;
        std::cout << "operator Value()" << std::endl;
        return ret;                                                
    }                    
};

int main()
{   
    Test t(100);
    Value v = t;

    return 0;                
}

從輸出結果我們可以發現：轉換構造函數和類型轉換函數發生沖突了，編譯器不知道應該調用哪個函數。因此發生了錯誤。
當然我們可以使用explicit關鍵字抑制隱式的轉換構造函數，讓程序只調用類型轉換函數。但是，我們無法抑制隱式的類型轉換函數

到此，關于“C++的operator()怎么使用”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續學習更多相關知識，請繼續關注億速云網站，小編會繼續努力為大家帶來更多實用的文章！