Une fonction qui renvoie un pointeur de fonction pour les fonctions de différents types de retour

Je ne suis pas tout à fait sûr du but ultime, mais voici comment vous pouvez faire la compilation ci-dessus et imprimer l'adresse de la fonction (impression d'un simple Add ajouté à titre de comparaison):

#include <iostream>
#include <string>

float Add(float a, float b) { return a + b; }
bool IfElse(bool a) { return a; }

union return_type
    {
    float(*ffptr)(float, float);
    bool(*bfptr)(bool);
    };  

union return_type fptr(std::string OPERATION) {
    union return_type r;
    if (OPERATION == "Add") {
        r.ffptr = Add;
    } else if (OPERATION == "IfElse") {
        r.bfptr = IfElse;
    }

    return r;
}

int main()
{
    /*the void*-cast is technically nonportable but it's hard to
      print fn-pointers portably*/
    std::cout << reinterpret_cast<void*>(Add) << '\n';

    /*you should know which union member is active: */
    std::cout << reinterpret_cast<void*>(fptr("Add").ffptr) << '\n';
    /*^should be the same address*/
    return 0;
}

Vous étiez proche. Veillez à ne pas confondre la déclaration du nom de type (union) et la valeur de retour de la fonction. Puisque vous voulez référencer l'adresse du pointeur, j'ai ajouté un void * à votre union (fpaddr), afin que vous puissiez clairement identifier que vous imprimez une adresse. Notez que votre fptr ("Add") a renvoyé l'union, et que vous deviez lever l'ambiguïté sur l'interprétation de l'union que vous vouliez.

#include <iostream>
#include <string>

float Add(float a, float b) { return a + b; }
bool IfElse(bool a) { if (a) { return true; } else { return false; }; }

//typedef //in C you would use 'typedef'
union fp_return_t
{
    float(* ffptr )(float, float);
    bool(* bfptr )(bool);
    void* fpaddr;
}; //fp_return_t; //in C you would give the name here

fp_return_t fptr(std::string OPERATION) {
    fp_return_t fp_return;
    if (OPERATION == "Add") {
        std::cout << "Add:" << (void*) Add << std::endl;
        fp_return.ffptr = Add;
    } else if (OPERATION == "IfElse") {
        std::cout << "IfElse:" << (void*) IfElse << std::endl;
        fp_return.bfptr = IfElse;
    }

    return fp_return;
}

int main() {
    std::cout << fptr("Add").fpaddr << std::endl;
    return 0;
}

Version TL; DR: Je pense que vous essayez peut-être de trouver une solution à l’ajustement un problème . Pensez à utiliser quelque chose comme le modèle de visiteur pour dissocier le problème afin que vous n'ayez pas besoin de savoir le type des données.

Une union n'est pas un type. C'est un type de types, comme une classe ou une struct . Pour utiliser un return_type , vous devez créer un objet qui est un return_type . Cela signifie que

#include <iostream>
#include <string>
#include <variant>

float Add(float a, float b) { return a + b; }
bool IfElse(bool a) { if (a) { return true; } else { return false; }; }

using return_type = std::variant<float (*)(float a, float b), bool (*)(bool a)>;

return_type fptr(std::string OPERATION) {
    return_type result;
    if (OPERATION == "Add") {
        result = Add;
    } else if (OPERATION == "IfElse") {
        result = IfElse;
    }

    return result;
}

int main() {
    std::cout << std::get<float (*)(float a, float b)>(fptr("Add"))(10,20) << std::endl;
    try
    {
        std::cout << std::get<bool (*)(bool a)>(fptr("Add"))(true) << std::endl;
    }
    catch (const std::bad_variant_access& e)
    {
        std::cout << e.what() << std::endl;
    }
        return 0;
}

doit ressembler davantage à

int main() {
    std::cout << fptr("Add").bfptr(true) << std::endl;
    return 0;
}

Alors vous pouvez

int main() {
    std::cout << fptr("Add").ffptr(10,20) << std::endl; // call the stored function
    return 0;
}