Comment stocker des fonctions avec des signatures non homogènes dans une carte en C ?

Stockage de fonctions avec des signatures non homogènes dans une carte

Introduction au problème

En C , il est nécessaire d'associer des fonctions avec des signatures différentes avec des signatures uniques identifiants pour l’appel dynamique basé sur les arguments d’exécution. Cependant, les conteneurs standard ne prennent pas directement en charge le stockage de types de fonctions non homogènes.

Utilisation des opérateurs d'effacement de type et de modèle

Une approche pour surmonter cette limitation est l'effacement de type, qui implique l'encapsulation de la fonction. types dans un conteneur qui efface les informations de type spécifiques. Cela permet le stockage uniforme de fonctions avec des signatures variables. Pour faciliter ce processus, une structure de données personnalisée, AnyCallable, est définie :

template<typename Ret>
struct AnyCallable
{
    AnyCallable() {}
    template<typename F>
    AnyCallable(F&& fun) : AnyCallable(std::function(std::forward<F>(fun))) {}
    template<typename ... Args>
    AnyCallable(std::function<Ret(Args...)> fun) : m_any(fun) {}
    template<typename ... Args>
    Ret operator()(Args&& ... args) 
    { 
        return std::invoke(std::any_cast<std::function<Ret(Args...)>>(m_any), std::forward<Args>(args)...); 
    }
    std::any m_any;
};

AnyCallable accepte des types de fonctions hétérogènes et fournit un opérateur générique() pour appeler la fonction encapsulée avec des arguments correspondants.

Exemple d'implémentation

En utilisant la structure de données AnyCallable, nous pouvons maintenant créer une carte qui stocke les fonctions avec différents signatures :

std::map<std::string, AnyCallable<void>> map;
map["foo"] = &foo;
map["bar"] = &bar;

Pour invoquer les fonctions de manière dynamique en fonction de leurs identifiants de chaîne uniques, nous utilisons l'opérateur() fourni par AnyCallable :

map["foo"](1, 2);
map["bar"]("Hello", 1, 2);

Cette approche garantit la sécurité des types et l'invocation dynamique de fonctions avec des signatures non homogènes, ce qui en fait une solution polyvalente pour stocker et exécuter des pointeurs de méthode avec différentes entrées.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!