Question

I’m using a library that defines some data type classes usually implemented as tight wrappers around a std::vector<>. The type hierarchy is several layers deep, mostly only adding elaborated constructors.

My problem: the base class defines its std::vector as private (which is fine), but only adds an accessor method as const. The derived class doesn’t even have access to it. The library looks like this (shorted for clarity):

template <class T> class BaseList
{
public:
    BaseList (const T data0) : data_ (1) { 
       data_[0] = data0; }

    const T & operator[] (const size_t nr) const { 
       // does out off bounds check here       
       return data_[nr]; }

private:
    std::vector<T> data_;
}

class FancyClass : public BaseList<SomeEnumType>
{
public:
    FancyClass (const SomeOtherEnumType data0) 
        : BaseList<SomeEnumType> ( static_cast<SomeEnumType> (data)) 
        {}
}

Now as I see it, the const definition is completely bogus. No internal method relies on the vector really being constant, neither do I in my external code.

What I like to do is simply this:

strukt MyType {
    FancyClass myData;
    bool otherData;
}

int main() {
    MyType storage = {FancyClass(0), false};

    storage.myData[0] = 5;
}

Which of course doesn’t work because of the const-ness. (“assignment of read-only location”)

With the responsibility completely on my side: is there some const_cast magic I could do to make this structure writable?
The only other possibility I know would be to completely replicate the type hierarchy in my code, but this would still leave me with either a lot of casts or a toFancyClass() function to call whenever I interface library code.

Any Ideas? Thanks!

(Please don’t comment on the code quality of the library. If I could change that, I wouldn’t be asking this question …)

Answer 1

Now as I see it, the const definition is completely bogus. No internal method relies on the vector really being constant, neither do I in my external code.

The const qualifier on a method doesn’t mean it relies on the vector being constant. It means that the method will not modify the state of the object. It is added so that the following code will compile.

void f(const FancyClass a)
{
    cout<<a[0];
}

The above code will not above compile without the const qualifiers on the [] method.

Anyway, the following should work

SomeEnumType & r = const_cast<SomeEnumType &>(storage.myData[0]);

r = b;

where b is an enum of type SomeEnumType

However if your storage object is actually a const object, then it will lead to undefined behaviour.