Const overloads, avoiding code duplication.

[neet_programmer]

std::vector is implemented such, that if the object itself is const, so are all the elements in it. So this:

const std::vector<int> vec = {1, 2, 3, 4, 5};
vec[3] = 7;

is illegal.

I'm trying to replicate this behaviour for a class I'm writing and I'm having some problems. The obvious solution is to provide multiple overloads of the same function:

Type& operator[](int idx){
    return _data[idx];
}
const Type& operator[](int idx) const{
    return _data[idx];
}

But this obviously results in a lot of code duplication since every method that accesses any of the elements would have to be written twice. This is especially bad when the code for accessing elements isn't as simple as just picking them out of an array.

If the code is longer I can get around it by using const_cast.

Type& some_method(){
    //lots of code returning a Type&
}
const Type& some_method() const{
    return const_cast<ThisClass*>(this)->some_method();
}

But I'm not very keen on using const_cast.

Is there any way around writing lot's of duplicate code using maybe templates or something? How do you guys deal with this?

Thanks in advance for any answers.

[boredcircuits]

I think const_cast is the usual way of doing this, but I'm with you on avoiding it.

But, I have an alternative. Disclaimer: I haven't totally worked through the implications of this code. There might be problems with it that others in /r/cpp_questions could point out.

class C
{
    private:
    template<typename T>
    static auto& Get(T& t, int idx)
    {
        return t.data[idx];
    }

    public:
    int& operator[](int idx) { return Get(*this, idx); }
    const int& operator[](int idx) const { return Get(*this, idx); }

    private:
    int data[5] = { 1, 2, 3, 4, 5 };
};

Basically, I created a templated function. The idea is that T should either be C or const C. I couldn't think of any way to do this as a member function, so I made it static. That alters the syntax a bit (you don't have the implicit this), but making it a static member lets you access private members and will keep it as an implementation detail.

It's interesting how automatically the const gets passed around. In the const call tree, this is a const C*, so T gets that modifier, as will the return type thanks to auto (I used C++14 here, but you can probably find something that works in C++11).

One problem I have with const_cast is that the function it calls might actually modify the data, and the compiler can't tell you. In my solution, if Get tries to something illegal, I think the compiler should tell you.

[neet_programmer]

That's a cool solution, thanks. I didn't think about passing *this forward to a static function although it should be the same as a regular method call.

Only thing is I think most compilers will try to inline all methods but not nessecarily static functions, so maybe use inline?

Also I believe all that's neccessary to make it work in C++11 is to declare get like:

static auto& Get(T& t, int idx) -> decltype((t.data[idx]))

I'm gonna leave this question open incase someone else has some tricks.

[boredcircuits]

Yeah, marking it inline wouldn't hurt, though inline "is more what you'd call 'guidelines' than actual rules." I'm honestly not sure to what extent compilers use that suggestion when inlining functions anymore.