std::map of polymorphic member variables pointers

Question

I'm working on implementing a map of member variables pointers associated with a string key. All variables range from a base class "BaseA" When accessing the variables from the map, it is only required to use the base class methods (getDesc () in the sample) so it is not necessary to retrieve the original type.

This code compiles and runs under GNU g ++ 6.2.1, but according to what I read, the use of reinterpret_cast is not portable and may not work with other compilers. Is this correct? Or does this code comply with C ++ standards? Is there any other way to do this without using the reinterpret_cast? One requirement is that "Vars" must be copyable with the default copy-contructor and copy-assignment implementations.

Sample code:

#include <iostream>
#include <sstream>
#include <map>
#include <typeinfo>

using namespace std;

struct BaseA
{
    virtual string getDesc()  = 0;
};

struct A1 : BaseA
{
    string getDesc() override { return "This is A1"; }
};

struct A2 : BaseA
{
    string getDesc() override { return "This is A2"; }
};

struct Vars
{
    A1 a1;
    A2 a2;

    map< string, BaseA Vars::* > vars;

    Vars()
    {
        vars["A1_KEY"] = reinterpret_cast<BaseA Vars::*>(&Vars::a1);
        vars["A2_KEY"] = reinterpret_cast<BaseA Vars::*>(&Vars::a2);
    }

    BaseA& get( const string& key )
    {
        auto it = vars.find( key );
        if ( it != vars.end())
        {
            return this->*(it->second);
        }
        throw std::out_of_range( "Invalid variable key:[" + key + "]");
    }
};                                

int main()
{
    Vars v;

    cout << "a1 description :" << v.get("A1_KEY").getDesc() << endl;
    cout << "a2 description :" << v.get("A2_KEY").getDesc() << endl;

    return 0;
}

Kind of unrelated but I'd recommend against using `std::string` as a key for `std::map`. If possible (as in most cases) use an `enum`. — DeiDei, Sep 25 '17 at 23:22
Thanks DeiDei. I use enum when is possible, but in this case, the idea is that the key is entered by the user as a command line, so I understand a string fits better — SNJ, Sep 26 '17 at 00:54

score 3 · Accepted Answer · answered Sep 25 '17 at 23:18

Yes, there are very few guarantees about what reinterpret_cast will do, and casting from one pointer to member to another is not one of them (unless you then cast back to the original type, which doesn't really help you).

The safe and easy way to do this one is using std::function:

struct Vars
{
    A1 a1;
    A2 a2;

    map< string, std::function<BaseA&(Vars&)> > vars;

    Vars()
    {
        vars["A1_KEY"] = &Vars::a1;
        vars["A2_KEY"] = &Vars::a2;
    }

    BaseA& get( const string& key )
    {
        auto it = vars.find( key );
        if ( it != vars.end())
        {
            return it->second(*this);
        }
        throw std::out_of_range( "Invalid variable key:[" + key + "]");
    }
};

Note that if you never need the vars dictionary to change, you could turn it into a static const member. (This would mean you need to define and initialize it outside the class in a source file.)

Could you explain a bit how it works... How could `&Vars::a1` be converted to a function? — Phil1970, Sep 26 '17 at 00:20
@Phil1970 The Standard doesn't say exactly how, only that a pointer-to-member is a valid [`Callable`](http://en.cppreference.com/w/cpp/concept/Callable) and that invoking it does either `arg.*ptm` or `(*arg).*ptm` depending on the type of `arg`. So it's similar to writing `[ptm](Vars& v) -> BaseA& { return v.*ptm; }` (but possibly more efficient, since a compiler-specific library *can* safely use things like `reinterpret_cast` tricks). — aschepler, Sep 26 '17 at 00:37

std::map of polymorphic member variables pointers

1 Answers1

Linked