Passing a map between classes

问题

This is in relation to an earlier question I had. I haven't managed to solve the problem there but for now I'm just trying to get better acquainted with the code to figure out how to deal with that problem.

Towards that goal, I've got around to trying out the suggestions given in that question and I'm a little stumped as to why the following isn't working.

in the header I have

class A {
public:
    typedef std::multimap<int, double> intdoublemap_t;
    const intdoublemap_t& getMap() const; 
    void setkey(int k);
    void setvalue(double v);
    void insertIntoMap();
    intdoublemap_t mMapA;

private:
    int key;
    double value;

};

class B {
public:
    typedef std::multimap<int, double> intdoublemap_t;
    void mapValues(const A& a);
private:
    intdoublemap_t mMapB;

};

in the implementation I have

const A::intdoublemap_t& A::getMap() const { return mMapA; }
void A::setkey(int k) { key = k; }
void A::setvalue(double v) { value = v; }
void A::insertIntoMap(){mMapA.insert(std::make_pair(key, value));}

void B::mapValues(const A & a){ const A::intdoublemap_t& mref = a.getMap();
                                mMapB = mref; }

and in main()

A a;
a.setkey(10);
a.setvalue(1232.2);
a.insertIntoMap();
B b;
b.mapValues(a);

The code compiles fine and everything to do with a works as expected but the map is not passing to b at all. It stays empty

Can anyone tell me why?

edit: I took another look at this and saw how to do it. I knew it was something stupidly basic. I just had to set mref in the function to a map in B and then could call a function to work on that map within B.

回答1:

As @FrancoisAndrieux notes, your getMap() only sets a reference local to the function - not the class' intdoublemap_t mref. If you want the latter to be a reference to a map elsewhere, you have three options:

• Make it intdoublemap_t& mref, initialize it on construction of the B instance.
• Make it std::reference_wrapper<intdoublemap_t> mref, set it whenever you want (e.g. in mapValues().
• Make it intdoublemap_t* (or std::shared_ptr<intdoublemap_t> in both A and B), set it whenever you like.

_{Note: As @FrancoisAndrieux says in a comment, with the second and third option (and without std::shared_ptr) you will have to be careful not to allow the reference to be used after the original object's lifetime has expired.}

Having said all the above - I must also say that your design seems rather off to me. You should really not be doing any of these things and I'm 99% sure you're approaching your task the wrong way.

来源：https://stackoverflow.com/questions/55461590/passing-a-map-between-classes