Jakie są funktory C ++ i ich zastosowania?

Często słyszę o funktorach w C ++. Czy ktoś może mi przedstawić, co to jest iw jakich przypadkach byłby użyteczny?

Funktor to właściwie tylko klasa, która definiuje operator (). Pozwala to tworzyć obiekty, które „wyglądają” jak funkcja:

// this is a functor
struct add_x {
  add_x(int val) : x(val) {}  // Constructor
  int operator()(int y) const { return x + y; }

private:
  int x;
};

// Now you can use it like this:
add_x add42(42); // create an instance of the functor class
int i = add42(8); // and "call" it
assert(i == 50); // and it added 42 to its argument

std::vector<int> in; // assume this contains a bunch of values)
std::vector<int> out(in.size());
// Pass a functor to std::transform, which calls the functor on every element 
// in the input sequence, and stores the result to the output sequence
std::transform(in.begin(), in.end(), out.begin(), add_x(1)); 
assert(out[i] == in[i] + 1); // for all i

Jest kilka fajnych rzeczy na temat funktorów. Jednym z nich jest to, że w przeciwieństwie do zwykłych funkcji, mogą zawierać stan. Powyższy przykład tworzy funkcję, która dodaje 42 do wszystkiego, co dasz. Ale ta wartość 42 nie jest zakodowana na stałe, została podana jako argument konstruktora podczas tworzenia naszej instancji funktora. Mógłbym utworzyć kolejny sumator, który dodał 27, po prostu wywołując konstruktor o innej wartości. Dzięki temu można je łatwo dostosowywać.

Jak pokazują ostatnie linie, często przekazujesz funktory jako argumenty do innych funkcji, takich jak std :: transform lub inne standardowe algorytmy biblioteczne. Możesz zrobić to samo ze zwykłym wskaźnikiem funkcji, z wyjątkiem, jak powiedziałem powyżej, funktorów można „dostosować”, ponieważ zawierają one stan, dzięki czemu są bardziej elastyczne (jeśli chciałbym użyć wskaźnika funkcji, musiałbym napisać funkcję która dodała dokładnie 1 do argumentu. Funktor jest ogólny i dodaje wszystko, czym go zainicjalizowałeś), a także potencjalnie bardziej wydajne. W powyższym przykładzie kompilator dokładnie wie, która funkcja std::transformpowinna zostać wywołana. Powinien zadzwonić add_x::operator(). Oznacza to, że może wstawić to wywołanie funkcji. To sprawia, że ​​jest tak samo wydajny, jak gdybym ręcznie wywołał funkcję dla każdej wartości wektora.

Gdybym zamiast tego przekazał wskaźnik funkcji, kompilator nie mógłby natychmiast zobaczyć, na którą funkcję wskazuje, więc jeśli nie wykona dość skomplikowanych globalnych optymalizacji, musiałby wyrejestrować wskaźnik w czasie wykonywania, a następnie wykonać wywołanie.

Mały dodatek. Możesz użyć boost::function, aby utworzyć funktory z funkcji i metod, takich jak:

class Foo
{
public:
    void operator () (int i) { printf("Foo %d", i); }
};
void Bar(int i) { printf("Bar %d", i); }
Foo foo;
boost::function<void (int)> f(foo);//wrap functor
f(1);//prints "Foo 1"
boost::function<void (int)> b(&Bar);//wrap normal function
b(1);//prints "Bar 1"

i możesz użyć boost :: bind, aby dodać stan do tego funktora

boost::function<void ()> f1 = boost::bind(foo, 2);
f1();//no more argument, function argument stored in f1
//and this print "Foo 2" (:
//and normal function
boost::function<void ()> b1 = boost::bind(&Bar, 2);
b1();// print "Bar 2"

i najbardziej przydatne, dzięki boost :: bind i boost :: function możesz stworzyć funktor z metody klasy, w rzeczywistości jest to delegat:

class SomeClass
{
    std::string state_;
public:
    SomeClass(const char* s) : state_(s) {}

    void method( std::string param )
    {
        std::cout << state_ << param << std::endl;
    }
};
SomeClass *inst = new SomeClass("Hi, i am ");
boost::function< void (std::string) > callback;
callback = boost::bind(&SomeClass::method, inst, _1);//create delegate
//_1 is a placeholder it holds plase for parameter
callback("useless");//prints "Hi, i am useless"

Możesz utworzyć listę lub wektor funktorów

std::list< boost::function<void (EventArg e)> > events;
//add some events
....
//call them
std::for_each(
        events.begin(), events.end(), 
        boost::bind( boost::apply<void>(), _1, e));

Jest jeden problem z tymi wszystkimi rzeczami, komunikaty o błędach kompilatora nie są czytelne dla człowieka :)

Functor to obiekt, który działa jak funkcja. Zasadniczo klasa, która definiuje operator().

class MyFunctor
{
   public:
     int operator()(int x) { return x * 2;}
}

MyFunctor doubler;
int x = doubler(5);

Prawdziwą zaletą jest to, że funktor może utrzymać stan.

class Matcher
{
   int target;
   public:
     Matcher(int m) : target(m) {}
     bool operator()(int x) { return x == target;}
}

Matcher Is5(5);

if (Is5(n))    // same as if (n == 5)
{ ....}

Nazwa „funktor” była tradycyjnie używana w teorii kategorii na długo przed pojawieniem się C ++ na scenie. Nie ma to nic wspólnego z koncepcją funktora w C ++. Lepiej jest używać obiektu funkcji nazwy zamiast tego, co nazywamy „funktorem” w C ++. W ten sposób inne języki programowania nazywają podobne konstrukcje.

Używany zamiast zwykłej funkcji:

Funkcje:

• Obiekt funkcji może mieć stan
• Obiekt funkcji pasuje do OOP (zachowuje się jak każdy inny obiekt).

Cons:

• Przynosi większą złożoność do programu.

Używany zamiast wskaźnika funkcji:

Funkcje:

• Obiekt funkcji często może być wstawiany

Cons:

• Obiekt funkcji nie może być zamieniony z innym typem obiektu funkcji podczas działania (przynajmniej chyba, że ​​rozszerzy on pewną klasę podstawową, co powoduje pewne obciążenie)

Używany zamiast funkcji wirtualnej:

Funkcje:

• Obiekt funkcji (niewirtualny) nie wymaga wywoływania vtable i środowiska wykonawczego, dlatego w większości przypadków jest bardziej wydajny

Cons:

• Obiekt funkcji nie może być zamieniony z innym typem obiektu funkcji podczas działania (przynajmniej chyba, że ​​rozszerzy on pewną klasę podstawową, co powoduje pewne obciążenie)

Jak inni wspominali, funktor to obiekt, który działa jak funkcja, tzn. Przeciąża operatora wywołania funkcji.

Funktory są powszechnie stosowane w algorytmach STL. Są użyteczne, ponieważ mogą utrzymywać stan przed wywołaniami funkcji i między nimi, jak zamknięcie w językach funkcjonalnych. Na przykład można zdefiniować MultiplyByfunktor, który zwielokrotnia jego argument przez określoną kwotę:

class MultiplyBy {
private:
    int factor;

public:
    MultiplyBy(int x) : factor(x) {
    }

    int operator () (int other) const {
        return factor * other;
    }
};

Następnie możesz przekazać MultiplyByobiekt do algorytmu takiego jak std :: transform:

int array[5] = {1, 2, 3, 4, 5};
std::transform(array, array + 5, array, MultiplyBy(3));
// Now, array is {3, 6, 9, 12, 15}

Kolejną zaletą funktora nad wskaźnikiem funkcji jest to, że wywołanie może być wstawiane w większej liczbie przypadków. Jeśli przekazałeś wskaźnik funkcji transform, chyba że to wywołanie zostanie wstawione, a kompilator wie, że zawsze przekazujesz mu tę samą funkcję, nie może on wstawić wywołania przez wskaźnik.

Dla początkujących, takich jak ja: po krótkiej analizie dowiedziałem się, co zrobił kod jalf.

Funktor to obiekt klasy lub struktury, który można „wywołać” jak funkcję. Jest to możliwe dzięki przeciążeniu () operator. () operator(Nie wiem, co jego nazwie) może przyjąć dowolną liczbę argumentów. Inni operatorzy biorą tylko dwie, tzn. + operatorMogą przyjmować tylko dwie wartości (po jednej z każdej strony operatora) i zwracają dowolną wartość, dla której ją przeciążono. Możesz zmieścić dowolną liczbę argumentów w jednym, () operatorco daje mu elastyczność.

Aby stworzyć funktor, najpierw musisz stworzyć swoją klasę. Następnie tworzysz konstruktor do klasy z parametrem wybranego typu i nazwy. Następnie w tej samej instrukcji znajduje się lista inicjalizująca (która korzysta z pojedynczego operatora dwukropka, co również było nowością), która konstruuje obiekty członków klasy z uprzednio zadeklarowanym parametrem dla konstruktora. A później() operator jest przeciążony. Na koniec deklarujesz prywatne obiekty klasy lub struktury, które utworzyłeś.

Mój kod (uznałem, że nazwy zmiennych Jalfa są mylące)

class myFunctor
{ 
    public:
        /* myFunctor is the constructor. parameterVar is the parameter passed to
           the constructor. : is the initializer list operator. myObject is the
           private member object of the myFunctor class. parameterVar is passed
           to the () operator which takes it and adds it to myObject in the
           overloaded () operator function. */
        myFunctor (int parameterVar) : myObject( parameterVar ) {}

        /* the "operator" word is a keyword which indicates this function is an 
           overloaded operator function. The () following this just tells the
           compiler that () is the operator being overloaded. Following that is
           the parameter for the overloaded operator. This parameter is actually
           the argument "parameterVar" passed by the constructor we just wrote.
           The last part of this statement is the overloaded operators body
           which adds the parameter passed to the member object. */
        int operator() (int myArgument) { return myObject + myArgument; }

    private: 
        int myObject; //Our private member object.
}; 

Jeśli którekolwiek z tych stwierdzeń jest niedokładne lub jest po prostu złe, popraw mnie!

Funktor jest funkcją wyższego rzędu, która stosuje funkcję do typów sparametryzowanych (tj. Szablonowych). Jest to uogólnienie funkcji wyższego rzędu mapy . Na przykład możemy zdefiniować funktor dla std::vectortego:

template<class F, class T, class U=decltype(std::declval<F>()(std::declval<T>()))>
std::vector<U> fmap(F f, const std::vector<T>& vec)
{
    std::vector<U> result;
    std::transform(vec.begin(), vec.end(), std::back_inserter(result), f);
    return result;
}

Ta funkcja przyjmuje wartość „a” std::vector<T>i zwraca ją, std::vector<U>gdy otrzyma funkcję „ Fa” Ti zwraca wartość a U. F funktor nie musi być definiowany dla typów kontenerów, można go również zdefiniować dla każdego typu szablonu, w tym std::shared_ptr:

template<class F, class T, class U=decltype(std::declval<F>()(std::declval<T>()))>
std::shared_ptr<U> fmap(F f, const std::shared_ptr<T>& p)
{
    if (p == nullptr) return nullptr;
    else return std::shared_ptr<U>(new U(f(*p)));
}

Oto prosty przykład, który konwertuje typ na double:

double to_double(int x)
{
    return x;
}

std::shared_ptr<int> i(new int(3));
std::shared_ptr<double> d = fmap(to_double, i);

std::vector<int> is = { 1, 2, 3 };
std::vector<double> ds = fmap(to_double, is);

Istnieją dwa prawa, których funktorzy powinni przestrzegać. Pierwszym z nich jest prawo tożsamości, które stanowi, że jeśli funktorowi zostanie przypisana funkcja tożsamości, to powinno być to samo, co zastosowanie funkcji tożsamości do typu, to znaczy fmap(identity, x)powinno być takie samo jak identity(x):

struct identity_f
{
    template<class T>
    T operator()(T x) const
    {
        return x;
    }
};
identity_f identity = {};

std::vector<int> is = { 1, 2, 3 };
// These two statements should be equivalent.
// is1 should equal is2
std::vector<int> is1 = fmap(identity, is);
std::vector<int> is2 = identity(is);

Kolejnym prawem jest prawo składu, które stwierdza, że ​​jeśli funktorowi zostanie dana kompozycja dwóch funkcji, to powinno być to samo, co zastosowanie funktora do pierwszej funkcji, a następnie do drugiej funkcji. Tak, fmap(std::bind(f, std::bind(g, _1)), x)powinna być taka sama, jak fmap(f, fmap(g, x)):

double to_double(int x)
{
    return x;
}

struct foo
{
    double x;
};

foo to_foo(double x)
{
    foo r;
    r.x = x;
    return r;
}

std::vector<int> is = { 1, 2, 3 };
// These two statements should be equivalent.
// is1 should equal is2
std::vector<foo> is1 = fmap(std::bind(to_foo, std::bind(to_double, _1)), is);
std::vector<foo> is2 = fmap(to_foo, fmap(to_double, is));

Oto faktyczna sytuacja, w której byłem zmuszony użyć Functora do rozwiązania mojego problemu:

Mam zestaw funkcji (powiedzmy 20 z nich) i wszystkie są identyczne, z wyjątkiem tego, że każda z nich wywołuje inną określoną funkcję w 3 określonych miejscach.

To niesamowite marnotrawstwo i powielanie kodu. Normalnie przekazałbym wskaźnik funkcji i nazwałbym to w 3 punktach. (Więc kod musi pojawić się tylko raz, a nie dwadzieścia razy.)

Ale potem zdałem sobie sprawę, że w każdym przypadku konkretna funkcja wymagała zupełnie innego profilu parametrów! Czasem 2 parametry, czasem 5 parametrów itp.

Innym rozwiązaniem byłoby posiadanie klasy bazowej, w której określona funkcja jest przesłoniętą metodą w klasie pochodnej. Ale czy naprawdę chcę zbudować całe to DZIEDZICTWO, tylko po to, aby przekazać wskaźnik funkcji ????

ROZWIĄZANIE: Więc stworzyłem klasę opakowania („Functor”), która jest w stanie wywoływać dowolne funkcje, które musiałem wywołać. Ustawiam go wcześniej (z jego parametrami itp.), A następnie przekazuję go zamiast wskaźnika funkcji. Teraz wywoływany kod może uruchomić Functor, nie wiedząc, co dzieje się wewnątrz. Może nawet zadzwonić kilka razy (potrzebowałem, żeby zadzwonić 3 razy).

To wszystko - praktyczny przykład, w którym Functor okazał się oczywistym i łatwym rozwiązaniem, które pozwoliło mi zmniejszyć duplikację kodu z 20 funkcji do 1.

Oprócz funkcji wywołania zwrotnego funktory C ++ mogą również pomóc w zapewnieniu Matlabowi stylu dostępu podobnego do klasy macierzy . Jest przykład .

Podobnie jak zostało to powtórzone, funktory to klasy, które można traktować jako funkcje (operator przeciążenia ()).

Są najbardziej przydatne w sytuacjach, w których trzeba powiązać niektóre dane z powtarzającymi się lub opóźnionymi wywołaniami funkcji.

Na przykład, połączona lista funktorów może być wykorzystana do implementacji podstawowego niskonakładowego synchronicznego systemu koroutynowego, programu rozsyłającego zadania lub analizy plików, którą można przerwać. Przykłady:

/* prints "this is a very simple and poorly used task queue" */
class Functor
{
public:
    std::string output;
    Functor(const std::string& out): output(out){}
    operator()() const
    {
        std::cout << output << " ";
    }
};

int main(int argc, char **argv)
{
    std::list<Functor> taskQueue;
    taskQueue.push_back(Functor("this"));
    taskQueue.push_back(Functor("is a"));
    taskQueue.push_back(Functor("very simple"));
    taskQueue.push_back(Functor("and poorly used"));
    taskQueue.push_back(Functor("task queue"));
    for(std::list<Functor>::iterator it = taskQueue.begin();
        it != taskQueue.end(); ++it)
    {
        *it();
    }
    return 0;
}

/* prints the value stored in "i", then asks you if you want to increment it */
int i;
bool should_increment;
int doSomeWork()
{
    std::cout << "i = " << i << std::endl;
    std::cout << "increment? (enter the number 1 to increment, 0 otherwise" << std::endl;
    std::cin >> should_increment;
    return 2;
}
void doSensitiveWork()
{
     ++i;
     should_increment = false;
}
class BaseCoroutine
{
public:
    BaseCoroutine(int stat): status(stat), waiting(false){}
    void operator()(){ status = perform(); }
    int getStatus() const { return status; }
protected:
    int status;
    bool waiting;
    virtual int perform() = 0;
    bool await_status(BaseCoroutine& other, int stat, int change)
    {
        if(!waiting)
        {
            waiting = true;
        }
        if(other.getStatus() == stat)
        {
            status = change;
            waiting = false;
        }
        return !waiting;
    }
}

class MyCoroutine1: public BaseCoroutine
{
public:
    MyCoroutine1(BaseCoroutine& other): BaseCoroutine(1), partner(other){}
protected:
    BaseCoroutine& partner;
    virtual int perform()
    {
        if(getStatus() == 1)
            return doSomeWork();
        if(getStatus() == 2)
        {
            if(await_status(partner, 1))
                return 1;
            else if(i == 100)
                return 0;
            else
                return 2;
        }
    }
};

class MyCoroutine2: public BaseCoroutine
{
public:
    MyCoroutine2(bool& work_signal): BaseCoroutine(1), ready(work_signal) {}
protected:
    bool& work_signal;
    virtual int perform()
    {
        if(i == 100)
            return 0;
        if(work_signal)
        {
            doSensitiveWork();
            return 2;
        }
        return 1;
    }
};

int main()
{
     std::list<BaseCoroutine* > coroutineList;
     MyCoroutine2 *incrementer = new MyCoroutine2(should_increment);
     MyCoroutine1 *printer = new MyCoroutine1(incrementer);

     while(coroutineList.size())
     {
         for(std::list<BaseCoroutine *>::iterator it = coroutineList.begin();
             it != coroutineList.end(); ++it)
         {
             *it();
             if(*it.getStatus() == 0)
             {
                 coroutineList.erase(it);
             }
         }
     }
     delete printer;
     delete incrementer;
     return 0;
}

Oczywiście te przykłady same w sobie nie są tak przydatne. Pokazują tylko, jak funktory mogą być użyteczne, same funktory są bardzo podstawowe i nieelastyczne, co czyni je mniej użytecznymi niż, na przykład, to, co zapewnia boost.

W gtkmm używane są funktory do połączenia przycisku GUI z rzeczywistą funkcją lub metodą C ++.

Jeśli użyjesz biblioteki pthread do wielowątkowej aplikacji, Functors może ci pomóc.
Aby rozpocząć wątek, jednym z argumentów tego wskaźnika pthread_create(..)jest wskaźnik funkcji, który należy wykonać na jego własnym wątku.
Ale jest jedna niedogodność. Ten wskaźnik nie może być wskaźnikiem do metody, chyba że jest to metoda statyczna lub jeśli nie określono jej klasy , jak class::method. I kolejną rzeczą, interfejs twojej metody może być tylko:

void* method(void* something)

Więc nie możesz uruchamiać (w prosty, oczywisty sposób) metod z twojej klasy w wątku bez robienia czegoś dodatkowego.

Bardzo dobrym sposobem radzenia sobie z wątkami w C ++ jest tworzenie własnej Threadklasy. Jeśli chcesz uruchomić metody z MyClassklasy, to co zrobiłem, przekształć te metody w Functorklasy pochodne.

Również Threadklasa ma tę metodę: static void* startThread(void* arg)
Wskaźnik do tej metody zostaną wykorzystane jako argument do rozmowy pthread_create(..). A to, co startThread(..)powinno otrzymać w arg, to void*rzutowane odwołanie do instancji w stercie dowolnej Functorklasy pochodnej, które zostanie rzutowane z powrotem Functor*po wykonaniu, a następnie nazwane jego run()metodą.

Aby dodać, użyłem obiektów funkcyjnych, aby dopasować istniejącą starszą metodę do wzorca poleceń; (tylko miejsce, w którym czułem piękno OO prawdziwego OCP); Dodając tutaj również odpowiedni wzorzec adaptera funkcji.

Załóżmy, że twoja metoda ma podpis:

int CTask::ThreeParameterTask(int par1, int par2, int par3)

Zobaczymy, jak możemy dopasować go do wzorca poleceń - w tym celu musisz najpierw napisać adapter funkcji członka, aby można go było wywołać jako obiekt funkcji.

Uwaga - jest to brzydkie i może być możliwe, że możesz użyć pomocników wiązania wzmocnienia, itp., Ale jeśli nie możesz lub nie chcesz, jest to jeden ze sposobów.

// a template class for converting a member function of the type int        function(int,int,int)
//to be called as a function object
template<typename _Ret,typename _Class,typename _arg1,typename _arg2,typename _arg3>
class mem_fun3_t
{
  public:
explicit mem_fun3_t(_Ret (_Class::*_Pm)(_arg1,_arg2,_arg3))
    :m_Ptr(_Pm) //okay here we store the member function pointer for later use
    {}

//this operator call comes from the bind method
_Ret operator()(_Class *_P, _arg1 arg1, _arg2 arg2, _arg3 arg3) const
{
    return ((_P->*m_Ptr)(arg1,arg2,arg3));
}
private:
_Ret (_Class::*m_Ptr)(_arg1,_arg2,_arg3);// method pointer signature
};

Potrzebujemy również metody pomocniczej mem_fun3 dla powyższej klasy, aby pomóc w wywołaniu.

template<typename _Ret,typename _Class,typename _arg1,typename _arg2,typename _arg3>
mem_fun3_t<_Ret,_Class,_arg1,_arg2,_arg3> mem_fun3 ( _Ret (_Class::*_Pm)          (_arg1,_arg2,_arg3) )
{
  return (mem_fun3_t<_Ret,_Class,_arg1,_arg2,_arg3>(_Pm));

}

Teraz, aby powiązać parametry, musimy napisać funkcję spoiwa. Oto on:

template<typename _Func,typename _Ptr,typename _arg1,typename _arg2,typename _arg3>
class binder3
{
public:
//This is the constructor that does the binding part
binder3(_Func fn,_Ptr ptr,_arg1 i,_arg2 j,_arg3 k)
    :m_ptr(ptr),m_fn(fn),m1(i),m2(j),m3(k){}

 //and this is the function object 
 void operator()() const
 {
        m_fn(m_ptr,m1,m2,m3);//that calls the operator
    }
private:
    _Ptr m_ptr;
    _Func m_fn;
    _arg1 m1; _arg2 m2; _arg3 m3;
};

I funkcja pomocnicza do użycia klasy binder3 - bind3:

//a helper function to call binder3
template <typename _Func, typename _P1,typename _arg1,typename _arg2,typename _arg3>
binder3<_Func, _P1, _arg1, _arg2, _arg3> bind3(_Func func, _P1 p1,_arg1 i,_arg2 j,_arg3 k)
{
    return binder3<_Func, _P1, _arg1, _arg2, _arg3> (func, p1,i,j,k);
}

Teraz musimy użyć tego z klasą Command; użyj następującego typedef:

typedef binder3<mem_fun3_t<int,T,int,int,int> ,T* ,int,int,int> F3;
//and change the signature of the ctor
//just to illustrate the usage with a method signature taking more than one parameter
explicit Command(T* pObj,F3* p_method,long timeout,const char* key,
long priority = PRIO_NORMAL ):
m_objptr(pObj),m_timeout(timeout),m_key(key),m_value(priority),method1(0),method0(0),
method(0)
{
    method3 = p_method;
}

Oto jak to nazywasz:

F3 f3 = PluginThreadPool::bind3( PluginThreadPool::mem_fun3( 
      &CTask::ThreeParameterTask), task1,2122,23 );

Uwaga: f3 (); wywoła metodę task1-> ThreeParameterTask (21,22,23) ;.

Pełny kontekst tego wzorca pod poniższym linkiem

Dużą zaletą implementacji funkcji jako funktorów jest to, że mogą utrzymywać i ponownie wykorzystywać stan między połączeniami. Na przykład wiele algorytmów programowania dynamicznego, takich jak algorytm Wagnera-Fischera do obliczania odległości Levenshteina między łańcuchami, działa poprzez wypełnienie dużej tabeli wyników. Przydzielanie tej tabeli przy każdym wywołaniu funkcji jest bardzo nieefektywne, więc implementacja funkcji jako funktora i uczynienie tabeli zmienną składową może znacznie poprawić wydajność.

Poniżej znajduje się przykład implementacji algorytmu Wagnera-Fischera jako funktora. Zwróć uwagę, w jaki sposób tabela jest przydzielana w konstruktorze, a następnie wykorzystywana ponownie operator(), z koniecznością zmiany rozmiaru.

#include <string>
#include <vector>
#include <algorithm>

template <typename T>
T min3(const T& a, const T& b, const T& c)
{
   return std::min(std::min(a, b), c);
}

class levenshtein_distance 
{
    mutable std::vector<std::vector<unsigned int> > matrix_;

public:
    explicit levenshtein_distance(size_t initial_size = 8)
        : matrix_(initial_size, std::vector<unsigned int>(initial_size))
    {
    }

    unsigned int operator()(const std::string& s, const std::string& t) const
    {
        const size_t m = s.size();
        const size_t n = t.size();
        // The distance between a string and the empty string is the string's length
        if (m == 0) {
            return n;
        }
        if (n == 0) {
            return m;
        }
        // Size the matrix as necessary
        if (matrix_.size() < m + 1) {
            matrix_.resize(m + 1, matrix_[0]);
        }
        if (matrix_[0].size() < n + 1) {
            for (auto& mat : matrix_) {
                mat.resize(n + 1);
            }
        }
        // The top row and left column are prefixes that can be reached by
        // insertions and deletions alone
        unsigned int i, j;
        for (i = 1;  i <= m; ++i) {
            matrix_[i][0] = i;
        }
        for (j = 1; j <= n; ++j) {
            matrix_[0][j] = j;
        }
        // Fill in the rest of the matrix
        for (j = 1; j <= n; ++j) {
            for (i = 1; i <= m; ++i) {
                unsigned int substitution_cost = s[i - 1] == t[j - 1] ? 0 : 1;
                matrix_[i][j] =
                    min3(matrix_[i - 1][j] + 1,                 // Deletion
                    matrix_[i][j - 1] + 1,                      // Insertion
                    matrix_[i - 1][j - 1] + substitution_cost); // Substitution
            }
        }
        return matrix_[m][n];
    }
};

Funkcję Functor można także wykorzystać do symulacji zdefiniowania funkcji lokalnej w funkcji. Zobacz pytanie i inne .

Ale lokalny funktor nie może uzyskać dostępu poza zmiennymi automatycznymi. Funkcja lambda (C ++ 11) jest lepszym rozwiązaniem.

„Odkryłem” bardzo interesujące użycie funktorów: używam ich, gdy nie mam dobrej nazwy dla jednej metody, ponieważ funktor jest metodą bez nazwy ;-)