Question

I have a couple of classes one of which keeps reference to the object of other:

class Inner {};

class Outer {
    Inner & in;

public:
    Outer(Inner & in) : in(in) {}
};

What if I have to create Outer object from const reference to Inner? Am I have to write specific class, say OuterConst, for this?

UPD: Any neat solutions using templates? In order to avoid duplication of code in OuterConst class.

UPD2: when Inner comes without const it should be modifiable (so I can’t just add const to Inner member in current implementation of Outer).

Answer 1

You could store a const reference, and use const_cast to cast the const away when needed. If you add some runtime checking, it’s also safe.

class Inner { /* ... */ };

class Outer {
    Inner const & in;
    bool const inIsConst;

    Inner & inMutable()
    {
        if (inIsConst)
            throw std::logic_error("in is const.");
        else
            return const_cast<Inner &>(in);
    }

public:
    Outer(Inner const & in) : in(in), inIsConst(true) {}
    Outer(Inner & in) : in(in), inIsConst(false) {}

    // always safe
    void Foo() { std::cout << in.getFoo(); }

    // will throw if *this was constructed with a const Inner
    void Bar() { inMutable().setFoo(in.getFoo() + 1); }
};

And of course you can always split this into two classes: one that cannot change in, and another that can.

To do this, you could either derive the class that can change in from the class that cannot. Or you could derive both from a common base class which has the common functions as protected members, and make the appropriate ones public with using Base::Function in the derived classes.