J'ai une lib écrite en C qui possède pas mal d'énums, et je veux la wrapper en C++
voici un exemple simplifié de l'un de ces enum avec ses fonctions associées:
enum TOTO
{
TOTO_NONE,
TOTO_A,
TOTO_B,
TOTO_C,
TOTO_NB,
};
const char* toto_get_name(enum TOTO toto);
int toto_get_associated_value(enum TOTO toto);
int toto_is_compatible(enum TOTO toto, int val);
Et pour ce faire, je vois deux méthodes qui ont chacune leurs avantages et inconvénients, la première est juste de créer un enum class et d'encapsuler les fonctions C en C++, ce qui donne un truc du genre:
enum class Toto
{
none = TOTO_NONE,
a = TOTO_A,
b = TOTO_B,
c = TOTO_C,
};
std::string_view name(TOTO toto){
return toto_get_name(static_cast<TOTO>(toto));
}
int associated_value(Toto toto){
return toto_get_associated_name(static_cast<TOTO>(toto));
}
bool is_compatible(Toto toto, int val){ return toto_get_associated_name(static_cast<TOTO>(toto), val);
}
La deuxième méthode est de créer une classe pour le type TOTO avec un enum classique interne et de transformer les fonctions libres en fonctions membres:
Pourquoi veux tu "wrapper" un enum ? C'est quoi le but recherché, vu qu'un enum C et un enum C++, c'est la même chose ? Meilleure API ? Sécurisation de la mémoire ?
La seule chose qui aurait pu être intéressant de wrapper, c'est le char* s'il y avait une gestion manuelle de la mémoire. Mais là, je sais pas trop.
En gros, ma réponse serait : celle qui répond a ton besoin. Mais je ne suis pas sûr de voir le besoin.
La principale raison est que cela permet d'avoir des variable typées, il y a notamment du polymorphisme C-style de fait et donc certaines variables de type int contiennent en fait des types enum en fonction du contexte et j'aimerai faire du "vrai" polymorphisme par dessus pour éviter les codes su style:
switch(type){
case TYPE_TOTO: return toto_get_name(val);
case TYPE_TUTU: return tutu_get_name(val);
case TYPE_TATA: return tata_get_name(val);
}
Tu sembles rechercher une résolution dynamique sur des types simple, c'est peut-être:
#include <string_view>
#include <variant>
class TOTO_A {
};
class TOTO_B {
};
class TOTO_C {
};
using UnTOTO = std::variant<TOTO_A,TOTO_B,TOTO_C>; // un TOTO_X
std::string_view get_name( TOTO_A val ) { return "toto_a"; } // résolution statique
std::string_view get_name( TOTO_B val ) { return "toto_b"; }
std::string_view get_name( TOTO_C val ) { return "toto_c"; }
std::string_view get_name( UnTOTO val ) { // résolution dynamique pour un TOTO_X quelconque
auto const lbd_get_name = [](auto val){return get_name(val);};
return std::visit( lbd_get_name, val );
}
int main() {
TOTO_A val_a;
get_name( val_a ); // résolution statique
UnTOTO un_toto = TOTO_B{};
get_name( un_toto ); // résolution dynamique
}
En recherche d'emploi.
Meilleur façon de wrapper un enum C en C++
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
Discord NaN. Mon site.
Discord NaN. Mon site.
En recherche d'emploi.