Ce que le C++ foncteurs et de leurs usages?

Un foncteur est à peu près juste une classe qui définit l'opérateur(). Qui vous permet de créer des objets qui "ressemble" à une fonction:

//this is a functor
struct add_x {
  add_x(int x) : x(x) {}
  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

Il y a un couple de belles choses à propos de foncteurs. L'une est que contrairement à des fonctions, elles peuvent contenir de l'état. L'exemple ci-dessus crée une fonction qui ajoute 42 à ce que vous la donner. Mais cette valeur 42 n'est pas codé en dur, il a été spécifié comme un argument du constructeur lorsque nous avons créé notre foncteur instance. Je pourrais créer une autre additionneur, qui a ajouté le 27, tout en appelant le constructeur avec une valeur différente. Cela les rend bien personnalisable.

Que les dernières lignes de présentation, vous devrez passer souvent foncteurs en tant qu'arguments d'autres fonctions telles que std::transform ou l'autre des algorithmes de la bibliothèque standard. On pourrait faire la même avec un pointeur de fonction, sauf, comme je l'ai dit ci-dessus, les foncteurs peuvent être "sur-mesure", car ils contiennent de l'état, en les rendant plus flexibles (Si je voulais utiliser un pointeur de fonction, je dois écrire une fonction qui a ajouté exactement 1 à son argument. Le foncteur est générale, et ajoute de ce que vous avez initialisé avec), et ils sont aussi potentiellement plus efficace. Dans l'exemple ci-dessus, le compilateur sait exactement quelle fonction std::transform devrait appeler. Il doit appeler add_x::operator(). Cela signifie qu'il peut inline cet appel de fonction. Et qui le rend tout aussi efficace que si j'avais manuellement appelé la fonction sur chaque valeur du vecteur.

Si j'avais passé un pointeur de fonction au lieu de cela, le compilateur ne pouvais pas voir immédiatement quelle fonction il points de, donc à moins qu'il effectue assez complexes optimisations globales, il faudrait déréférencer le pointeur au moment de l'exécution, et ensuite faire l'appel.

Un Foncteur est un objet qui se comporte comme une fonction.
Fondamentalement, une classe qui définit operator().

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

MyFunctor doubler;
int x = doubler(5);

Le véritable avantage, c'est qu'un foncteur peut contenir de l'état.

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)
{ ....}

Comme d'autres l'ont mentionné, l'un foncteur est un objet qui se comporte comme une fonction, c'est à dire qu'il surcharges de l'opérateur d'appel de fonction.

Foncteurs sont couramment utilisés dans les algorithmes de la STL. Ils sont utiles car ils peuvent contenir de l'état avant et entre les appels de fonction, comme une fermeture dans les langages fonctionnels. Par exemple, vous pouvez définir un MultiplyBy foncteur qui multiplie son argument par une quantité spécifiée:

class MultiplyBy {
private:
    int factor;

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

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

Ensuite, vous pouvez passer une MultiplyBy objet d'un algorithme de type 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}

Un autre avantage d'un foncteur sur un pointeur à une fonction, c'est que l'appel peut être incorporé dans plus de cas. Si vous avez passé un pointeur de fonction à transform, à moins que que appel obtenu inline et le compilateur sait que vous passez toujours la même fonction, il ne peut pas inline l'appel à l'aide du pointeur.

Un foncteur est une fonction d'ordre supérieur qui applique une fonction à la paramétrées(c'est à dire basée sur des modèles types. C'est une généralisation de la carte fonction d'ordre supérieur. Par exemple, on pourrait définir un foncteur pour std::vector comme ceci:

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;
}

Cette fonction prend un std::vector<T> et retourne std::vector<U> lorsque la fonction F qui prend un T et renvoie un U. Un foncteur n'ont pas à être définis sur les types de conteneurs, il peut être défini pour tout basé sur un modèle type, y compris 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)));
}

Heres un exemple simple qui convertit le type de 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);

Il y a deux lois qui foncteurs devraient suivre. La première est l'identité de la loi, qui stipule que si le foncteur est donné une identité de fonction, il doit être le même que l'application de la fonction d'identification du type, c'est-à fmap(identity, x) doit être le même que 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);

La prochaine loi est la composition de la loi, qui stipule que si le foncteur est donné une composition de deux fonctions, il doit être le même que l'application du foncteur de la première fonction, puis à nouveau pour la deuxième fonction. Donc, fmap(std::bind(f, std::bind(g, _1)), x) doit être le même que 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));

À l'exception de rappel, C++ foncteurs peuvent aussi aider à fournir un Matlab goût d'accès du style à une matrice classe. Il y a un exemple.

À ajouter ,j'ai utilisé la fonction des objets pour s'adapter à un existant méthode héritée du modèle de commande; (le seul endroit où la beauté de paradigme OO vrai OCP j'ai ressenti );
Aussi l'ajout d'ici la fonction de l'adaptateur.

Supposons que votre méthode a pour signature:

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

Nous allons voir comment nous pouvons ajuster le modèle de Commande - pour cela, tout d'abord, vous devez écrire une fonction membre de l'adaptateur de sorte qu'il peut être appelée comme une fonction de l'objet.

Remarque - ce qui est laid, et peut-être vous pouvez utiliser le Boost lier les aides etc., mais si vous ne pouvez pas ou ne voulez pas, c'est une façon.

//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
};

Aussi, nous avons besoin d'une méthode d'aide mem_fun3 pour la classe ci-dessus à l'aide de l'appel.

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));

}

Maintenant, afin de lier les paramètres, nous avons à écrire un classeur fonction. Donc, ici, il va:

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;
};

Et, une fonction d'aide pour l'utilisation de la binder3 classe - 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);
}

Maintenant, nous avons pour l'utiliser avec la classe de Commande; utiliser le typedef suivant:

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;
}

Ici est de savoir comment vous l'appelez:

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

Remarque: f3(); va appeler la méthode task1->ThreeParameterTask(21,22,23);.

Le contexte de ce modèle, à l' lien

Un gros avantage de la mise en œuvre de fonctions comme les foncteurs est qu'ils peuvent se maintenir et la réutilisation de l'état entre les appels. Par exemple, de nombreux algorithmes de programmation dynamique, comme le Wagner-Fischer algorithme pour le calcul de la Levenshtein entre les chaînes, travail en remplissant un grand tableau de résultats. C'est très inefficace pour allouer cette table à chaque fois que la fonction est appelée, pour la mise en œuvre de la fonction comme un foncteur et la table d'une variable de membre peut améliorer considérablement les performances.

Ci-dessous est un exemple de mise en œuvre de la Wagner-Fischer algorithme comme un foncteur. Remarquez comment le tableau est alloué dans le constructeur, et puis réutilisés dans operator(), avec redimensionnement comme nécessaire.

#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];
}
};

J'ai "découvert" une utilisation très intéressante de foncteurs: je les utilise quand je n'ai pas un bon nom pour une méthode, comme un foncteur est une méthode sans nom 😉