Comment appeler le foncteur operator() en C++

En C++, un foncteur est un objet qui peut être appelé comme une fonction. Un foncteur est une classe qui surcharge l'opérateur d'appel de fonction `operator()`. En surchargeant `operator()`, un objet peut être appelé comme une fonction, et il peut être passé comme paramètre de fonction ou valeur de retour. Lorsque vous utilisez un foncteur, vous devez utiliser son objet comme nom de fonction, suivi de la liste des paramètres. Cela appellera automatiquement l'opérateur `operator()` du foncteur pour effectuer l'opération correspondante. Par exemple:
 

#include <iostream>

// 定义一个简单的仿函数
struct MyFunctor {
    void operator()(int x) const {
        std::cout << "The value is: " << x << std::endl;
    }
};

int main() {
    MyFunctor f;
    f(42);  // 调用仿函数
    return 0;
}

Dans l'exemple de code ci-dessus, un foncteur simple "MyFunctor" est défini, qui accepte un paramètre de type "int" et renvoie la valeur de ce paramètre. Dans la fonction `main()`, un objet `f` de type `MyFunctor` est créé, puis l'objet `f` est appelé à l'aide de l'opérateur d'appel de foncteur `operator()`, en passant le paramètre `42`. Cela appellera automatiquement l'opérateur `operator()` de `MyFunctor` et affichera un message avec la valeur `42`.

Il est important de noter que les foncteurs sont appelés à peu près de la même manière que les fonctions, mais il existe quelques différences importantes. L'une des différences est que les foncteurs peuvent stocker l'état, alors que les fonctions ne le peuvent pas. Par conséquent, dans certains cas, il est plus pratique d'utiliser des foncteurs pour implémenter des fonctions spécifiques, telles que des opérations telles que le tri, le filtrage et le mappage d'objets de fonction. De plus, les foncteurs peuvent également être utilisés avec des algorithmes dans la STL (Standard Template Library) pour fournir des fonctionnalités encore plus puissantes et flexibles.

En bref, un foncteur en C++ est un objet qui peut être appelé comme une fonction, qui surcharge l'opérateur d'appel de fonction `operator()`. Lorsque vous utilisez un foncteur, vous devez utiliser son objet comme nom de fonction, suivi de la liste des paramètres. Cela appellera automatiquement l'opérateur `operator()` du foncteur pour effectuer l'opération correspondante.

Comment appeler par pointeur ?

En C++, les pointeurs peuvent être utilisés pour appeler des fonctions ou des foncteurs. Un pointeur est une variable qui stocke l'adresse d'une autre variable accessible via l'opérateur de déréférencement `*`. La méthode d'appel d'une fonction ou d'un foncteur via un pointeur est très similaire à l'appel direct d'une fonction ou d'un foncteur. Il vous suffit d'utiliser le pointeur comme nom de fonction ou nom de foncteur. Voici un exemple de code qui montre comment appeler une fonction simple via un pointeur :
 

#include <iostream>

// 定义一个简单的函数
void myFunction(int x) {
    std::cout << "The value is: " << x << std::endl;
}

int main() {
    // 声明一个指向函数的指针
    void (*pFunction)(int) = &myFunction;

    // 通过指针调用函数
    (*pFunction)(42);

    return 0;
}

Dans l'exemple de code ci-dessus, une fonction simple "myFunction" est d'abord définie, qui accepte un paramètre de type "int" et renvoie la valeur de ce paramètre. Ensuite, dans la fonction `main()`, un pointeur vers la fonction `pFunction` est déclaré, et il est initialisé à `&myFunction`, c'est-à-dire l'adresse de la fonction `myFunction`. Enfin, appelez la fonction `(*pFunction)(42)` via le pointeur, de sorte que la fonction `myFunction` sera appelée automatiquement, et le paramètre `42` sera passé, et la valeur de sortie sera `42`. De même, les foncteurs peuvent également être appelés via des pointeurs. Voici un exemple de code qui montre comment appeler un foncteur simple via un pointeur :
 

#include <iostream>

// 定义一个简单的仿函数
struct MyFunctor {
    void operator()(int x) const {
        std::cout << "The value is: " << x << std::endl;
    }
};

int main() {
    // 声明一个仿函数对象
    MyFunctor f;

    // 声明一个指向仿函数的指针
    MyFunctor* pFunctor = &f;

    // 通过指针调用仿函数
    (*pFunctor)(42);

    return 0;
}

Dans l'exemple de code ci-dessus, un foncteur simple "MyFunctor" est d'abord défini, qui accepte un paramètre de type "int" et renvoie la valeur de ce paramètre. Ensuite, dans la fonction `main()`, un objet `f` de type `MyFunctor` est créé, et un pointeur `pFunctor` pointant vers le type `MyFunctor` est déclaré, et il est initialisé comme `&f`, qui pointe to` L'adresse de l'objet f`. Enfin, appelez le foncteur `(*pFunctor)(42)` via le pointeur, de sorte que l'opérateur `operator()` de `MyFunctor` soit appelé automatiquement et que la valeur de sortie soit `42`.

Il convient de noter que lors de l'utilisation d'un pointeur pour appeler une fonction ou un foncteur, l'opérateur de déréférencement "*" doit être utilisé pour déréférencer le pointeur en tant que fonction ou foncteur. Dans le même temps, vous pouvez également utiliser l'opérateur fléché `->` pour accéder aux membres pointant vers l'objet foncteur, par exemple :
 

MyFunctor* pFunctor = &f;
pFunctor->operator()(42);

De cette façon, le foncteur peut également être appelé via le pointeur, et la valeur de sortie est '42'.

En résumé, en C++, vous pouvez utiliser des pointeurs pour appeler des fonctions ou des foncteurs. La méthode d'appel d'une fonction ou d'un foncteur via un pointeur est très similaire à l'appel direct d'une fonction ou d'un foncteur. Il vous suffit d'utiliser le pointeur comme nom de fonction ou nom de foncteur. Lorsque vous utilisez un pointeur pour appeler une fonction ou un foncteur, vous devez utiliser l'opérateur de déréférencement `*` pour déréférencer le pointeur en tant que fonction ou foncteur. En même temps, vous pouvez également utiliser l'opérateur fléché `->` pour accéder aux membres pointant vers l'objet foncteur.