Puis-je extraire des membres de la classe struct ou public à l'aide d'un modèle?

Question

Fondamentalement, j'ai beaucoup de struct différemment typés comme ceci:

typedef struct 
{ 
    char memberA; 
    int memberB; 
    ... 
} tStructA; 

Est-il possible d'utiliser un modèle pour obtenir/extraire un membre arbitraire du struct? Dans pseudocode, je cherche quelque chose comme ceci:

/*This is pseudocode!*/ 
template <typename STRUCT_TYPE, typename MEMBER_TYPE, membername NAME> 
class cMemberExtractor 
{ 
    public: 
     MEMBER_TYPE 
     extract(const STRUCT_TYPE* pStruct) const 
     { 
      return pStruct->NAME; 
     } 
};  

L'idée est derrière d'utiliser le modèle comme celui-ci:

/*somewhere*/ 
void 
producer() 
{ 
    //produce update 
    tStructA* pUpdate=new tStructA; 
    ... 
    //send update to receivers 
    emit(pUpdate); 
} 


/*elsewhere*/ 
void 
consumer(const tStructA* pUpdate) 
{ 
    //extract data 
    int data=cMemberExtractor<tStructA,int,memberB>().extract(pUpdate); 
    //process data 
    ... 
} 

Merci pour votre aide!

Answer 1

Vous pouvez le faire avec les noms mais avec des pointeurs membres:

template <typename C, typename M> 
struct updater_t { 
    typedef M C::*member_ptr_t; 

    updater_t(member_ptr_t ptr, M const & new_value) 
     : new_value(new_value), ptr(ptr) 
    {} 
    updater_t(member_ptr_t ptr, C & original) 
     : new_value(original.*ptr), ptr(ptr) 
    {} 
    void operator()(C & obj) { 
     obj.*ptr = new_value; 
    } 
    M new_value; 
    member_ptr_t ptr; 
}; 
struct test { 
    int value; 
}; 
int main() { 
    updater_t<test,int> update(&test::value, 10); 
    test object; 
    update(object); 

    test object2; 
    updater_t<test,int> update_copy(&test::value, object); 
    update_copy(object2); 
} 

Modifier: Déplacement du pointeur de membre à un argument de modèle tel que suggéré par litb:

template <typename C, typename M, M C::* Ptr> 
struct updater_t { 
    updater_t(M const & new_value) : new_value(new_value) {} 
    updater_t(member_ptr_t ptr, C & original) : new_value(original.*Ptr) {} 
    void operator()(C & obj) { 
     obj.*ptr = new_value; 
    } 
    M new_value; 
}; 
int main() { 
    updater_t<test,int, &test::value> update(10); 
    test object; 
    update(object); 
} 

Answer 2

Vous avez besoin d'aide des macros.

#include <cstddef> 

template <typename StructType, typename MemberType, size_t member_offset> 
struct cMemberExtractor { 
     MemberType extract(const StructType* pStruct) const { 
      const char* member_loc = reinterpret_cast<const char*>(pStruct) + member_offset; 
      return *(reinterpret_cast<const MemberType*>(member_loc)); 
     } 
}; 

#define M_MEMBER_EXTRACTOR(STRU, MEMTYPE, MEMNAME) \ 
(cMemberExtractor<STRU,MEMTYPE,offsetof(STRU,MEMNAME)>()) 
... 

int data = M_MEMBER_EXTRACTOR(tStructA,int,memberB).extract(pUpdate); 

---

Si votre compilateur prend en charge l'opérateur typeof, l'argument MEMTYPE peut être éliminé pour aider la sécurité de type.

#define M_MEMBER_EXTRACTOR(STRU, MEMNAME) \ 
(cMemberExtractor<STRU,typeof(((STRU*)0)->MEMNAME),offsetof(STRU,MEMNAME)>()) 
... 

int data = M_MEMBER_EXTRACTOR(tStructA,memberB).extract(pUpdate); 

Answer 3

Cela fonctionne pour moi:

#include <iostream> 

struct Foo { 
    int member; 
    Foo() : member() {} 
}; 

template< typename T, typename C > 
T& extract(C& obj, T C::* member) 
{ 
    return (obj.*member); 
} 

int main() 
{ 
    Foo foo; 
    std::cout << foo.member << '\n'; 
    extract(foo, &Foo::member) = 42; 
    std::cout << foo.member << '\n'; 
    return 0; 
} 

extract(Object, &Class::Member) renvoie une référence à Member dans Object. Est-ce ce que tu voulais?