CODEWITHSUNDEEP
c++constants
Chaos_99
Chaos_99

Reputation: 2304

How to work around 'const' definition in library

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 ...)

Upvotes: 0

Views: 830

Answers (3)

BЈовић
BЈовић

Reputation: 64223

The simplest would be to add non-const version of the operator[]. Otherwise, you might cause an UB by casting away the constness with using const_cast.

You can throw away the constness like this :

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

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

Upvotes: 1

user93353
user93353

Reputation: 14039

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.

Upvotes: 1

MFH
MFH

Reputation: 1734

Normally operator[] comes in pairs of a mutable and a const version.. (See: Operator overloading)

Of course there is a const_cast-based solution, but it involves undefined behaviour (you're not allowed to change a value after casting away constness!)

Upvotes: 0

Related Questions