Est-il possible de fusionner la classe de base?

Question

Est-il possible de fusionner-adapter la classe de base comme s'il s'agissait d'un membre?

Tout d'abord c'est l'exemple de documentation, côte à côte avec le nouveau cas:

#include <boost/fusion/adapted/struct/adapt_struct.hpp> 
#include <boost/fusion/include/adapt_struct.hpp> 

struct employee{ 
    std::string name; 
    int age; 
}; 

BOOST_FUSION_ADAPT_STRUCT(
    employee, 
    (std::string, name) 
    (int, age)) 

struct employee2 : std::string{ 
    int age; 
}; 

BOOST_FUSION_ADAPT_STRUCT(
    employee2, 
    (std::string, name) ??? 
    (int, age)) 


int main(){} 

Que dois-je mettre dans la ligne avec le ???.

Actuellement, la seule solution que j'ai trouvé est de le faire, mais 1) Je dois rendre tous les membres getter et les fonctions de réglage 2) semble être une exagération.

#include <boost/fusion/adapted/adt/adapt_adt.hpp> 
struct employee2 : std::string{ 
    int age; 
    void set_base(std::string const& age_){std::string::operator=(age_);} 
    std::string const& get_base() const{return static_cast<std::string const&>(*this);} 
    void set_age(int const& age_){age = age_;} 
    int const& get_age() const{return age;} 
}; 

BOOST_FUSION_ADAPT_ADT(
    employee2, 
    (std::string, std::string, obj.get_base(), obj.set_base(val)) 
    (int, int, obj.get_age(), obj.set_age(val)) 
) 

Answer 1

Eh bien, il semble (par l'expérimentation) que l'on peut mettre toutes sortes d'expressions valides dans BOOST_FUSION_ADAPT_ADT. Je ne suis pas très sûr que cela soit optimal (par exemple si la fusion va faire des copies en accédant aux éléments), alors d'autres réponses sont les bienvenues.

#include <boost/fusion/adapted/adt/adapt_adt.hpp> 
BOOST_FUSION_ADAPT_ADT(
    employee2, 
    (static_cast<std::string const&>(obj), obj.std::string::operator=(val)) 
    (obj.age, obj.age = val) 
) 

int main(){ 

    employee2 e2; 
    boost::fusion::at_c<0>(e2) = "Pepe"; 
    boost::fusion::at_c<1>(e2) = 37; 

    cout << e2 << " " << e2.age <<'\n'; 

} 

Cela peut empêcher des copies et semble fonctionner dans plus de cas (par exemple boost::fusion::copy) mais je ne sais pas pourquoi:

BOOST_FUSION_ADAPT_ADT(
    employee2, 
    (std::string, std::string const&, obj, obj.std::string::operator=(val)) 
    (int, int const&, obj.age, obj.age = val) 
)