adapter pattern : support underlying data that can be const or non-const, elegantly

Question

How to make an adapter class to support both const and non-const underlying data appropriately?

Concrete Example

RigidBody is a class describing physic property of object.
Here is its very simplified version (1D):-

class RigidBody{
    float position=1;
    public: float getPosition()const{ return position;}
    public: void setPosition(float ppos){ position=ppos;}
};

Adapter encapsulates RigidBody.
It provides a-little-distorted functionality to get/set position:-

class Adapter{
    public: RigidBody* rigid; int offset=2;
    public: float getPosition(){
        return rigid->getPosition()+offset;     //distort
    }
    public: void setPosition(float ppos){
        return rigid->setPosition(ppos-offset); //distort
    }
};

I can set position of RigidBody indirectly by using Adapter :-

int main() {
    RigidBody rigid;
    Adapter adapter;  //Edit: In real life, this type is a parameter of many function
    adapter.rigid=&rigid;
    adapter.setPosition(5);
    std::cout<<adapter.getPosition();//print 5
    return 0;
}

Everything works (demo).

Objective

I want create a new function that receives constRigidBody* rigid.
I should be able to read from it (e.g. getPosition()) by using adapter.

However, I don't really know how to do it elegantly.

void test(const RigidBody* rigid){
    Adapter adapter2; 
    //adapter2.rigid=rigid; //not work, how to make it work?
    //adapter2.setPosition(5); //should not work
    //adapter2.getPosition();  //should work 
}

My poor solutions

Solution A1 (2 adapters + 1 widget)

Create a widget :-

class AdapterWidget{
    public: static Adapter createAdapter(RigidBody* a);
    public: static AdapterConst createAdapter(const RigidBody* a);
};

AdapterConst can only getPosition(), while AdapterConst can both get and set.

I can use it like :-

void test(const RigidBody* rigid){
    auto adapter=AdapterWidget::createAdapter(rigid);

It is easy to use.

Disadvantage: Code of AdapterConst and Adapter will be very duplicated.

Solution A2 (+inheritance)

It is an improvement of the previous solution.
Let Adapter (has setPosition()) derive from AdapterConst (has getPosition()).

Disadvantage: It is not concise. I use 2 classes for the single task!
This might seem to be trivial, but in a bigger code-base, it is not fun at all.

Specifically, location of getPosition() will be far-away from setPosition(), e.g in different files.
This causes maintainability problem.

Solution B (template)

Create a template class. There are many ways e.g. :-

• Adapter<T =RigidBody OR const RigidBody >
• Adapter<bool=true is const OR false is non-const >

Disadvantage: In every ways, it is inelegant. It is an overkill. (?)
I will suffer from disadvantage of template e.g. everything in header.

Solution C1 (const_cast)

I am trying to avoid it. It is evil.

class Adapter{
    public: RigidBody* rigid; 
    void setUnderlying(const RigidBody* r){
        rigid=const_cast< RigidBody*>(r);
    }
    ....
};

Solution C2 (+manual assert)

I can add some assertion manually.
It just emphasizes how much it is unprofessional :-

    bool isConst;
    void setUnderlying(const RigidBody* r){
        ...
        isConst=true;
    }
    void setUnderlying(RigidBody* r){
        ...
        isConst=false;
    }
    void setPosition(float a){
        if(isConst){ /*throw some exception*/ }
        ....
    }

Solution D (run away)

• Lazy : change from test(constRigidBody* rigid) to test(RigidBody* rigid).
• Crazy : change RigidBody::setPosition() to be const.

In either way, my program will not be const-correct any more,
but a single Adapter class would be enough.

Question

Do I really have to do one of these things wherever I encounter the const/non-const pattern?
Please provide a pretty solution. (no full code is required, but I don't mind)

Sorry for the long post.

Edit: In real life, Adapter is a parameter for many function.
It is passed around like a toy.

Most of such functions don't have knowledge about RigidBody, so it is not quite suitable to change from a bundle calling someFunction(adapter) to someFunction(offset,rigidbody).

Answer 1

You shouldn't keep with that idea. This is C++, not Java.

Your code is extremely Java oriented. I can see it by the way you write the code, use pointers and silently omit const when needed.

In fact, most of the bad C++ code that I personally saw is pretty much either written to be "C inside classes" or "Java without GC". Both of them are extremely bad ways of writing C++ code.

Your question has an idiomatic solution:

1. Ditch most of the design patterns. they are useful for languages where object are reference types by default. C++ prefers most of the times to tread object as value types and prefer static polymorphism (templates) rather than run-time polymorphism (inherit + override).

2. Write two classes , one is Adapter and one is ConstAdapter. This is what the standard library already does. every container has different iterator and const_iterator implementation exactly because of that reason. you can either store something by pointer, either by const pointer. It is error prone trying to mix the two. If there were a nice solution for that problem, we wouldn't have two iterator typedefs for each container.

Answer 2

A tightly controlled const_cast looks like a good solution to me:

// Only provides read-only access to the object
struct ConstAdapter {
    int offset = 2;

    // Constructible from const and non-const RigidBodies
    ConstAdapter(RigidBody const *rigid)
    : _rigid{rigid} { }

    // Read-only interface
    float getPosition() {
        return rigid()->getPosition() + offset;     //distort
    }

    // Hidden away for consistency with Adapter's API
    // and to prevent swapping out an "actually non-const" RigidBody
    // for a "truly const" one (see  Adapter::rigid()`).
    RigidBody const *rigid() const { return _rigid; }

private:
    RigidBody const *_rigid;
};

// Inherits read-only functions, and provides write access as well
struct Adapter : ConstAdapter {

    // Only constructible from a non-const RigidBody!
    Adapter(RigidBody *rigid) : ConstAdapter{rigid} { }

    // Write interface
    void setPosition(float ppos){
        return rigid()->setPosition(ppos-offset); //distort
    }

    // Here's the magic part: we know we can cast `const` away
    // from our base class' pointer, since we provided it ourselves
    // and we know it's not actually `const`.
    RigidBody *rigid() const {
        return const_cast<RigidBody *>(ConstAdapter::rigid());
    }
};

Regarding:

Specifically, location of getPosition() will be far-away from setPosition(), e.g in different files. This causes maintainability problem.

This is a non-issue. C++, unlike Java, allows multiple classes in a single file, and you are in fact encouraged to group such tightly related classes together. The declarations of the functions will be only a handful of lines apart, and their definitions can very well be grouped together in the corresponding .cpp file.

Answer 3

Use references instead of pointers, and let the const-ness propogate to the Adapter. Then you can safely const_cast, as

template <class Rigid>
class Adapter{
    Rigid & rigid;
    int offset;
public: 
    Adapter(Rigid & rigid, int offset = 2) : rigid(rigid), offset(offset) {}
    float getPosition() const { return rigid.getPosition() + offset; }
    void setPosition(float ppos) { rigid.setPosition(ppos - offset); }
};

Answer 4

My first instinct would be to access a RigidBody through an Adaptor and a const RigidBody through a const Adaptor. To achieve this, we use a factory to create the right kind of Adaptor, and in the implementation, we access the underlying RigidBody through an accessor method that (safely) casts only when allowed.

The code:

Start with the private members:

class Adaptor
{
    RigidBody const& body;
    int offset;

    Adaptor(RigidBody body, int offset=2)
        : body(body),
          offset(offset)
    {}

    Adaptor(const Adaptor&) = delete;

The constructor is private, so we can only create instances through our factory. And we remove the copy constructor, so we can't create a non-const Adaptor from a const one.

Next, we have our first overloaded pair - the accessor used in the implementation. I've marked it protected, in case you want a range of similar adaptors. It could safely be public if you want, though.

protected:
    RigidBody& get_body() { return const_cast<RigidBody&>(body); }
    RigidBody const& get_body() const { return body; }

We know that the const_cast is safe, because we only get a non-const Adaptor from a non-const RigidBody, as we see in the other overloaded pair, which is the factory:

public:
    static Adaptor *adapt(RigidBody& body, int offset = 2) { return new Adaptor{ body, offset }; }
    static Adaptor const *adapt(RigidBody const& body, int offset = 2) { return new Adaptor{ body, offset }; }

From here on, each method is declared const unless it needs to modify the body, just as you'd expect. So, if you have a const Adaptor (which you will if you constructed it from a const RigidBody, you can't call any method that modifies body. And the implementation can't modify body from within any of the const methods.

    float getPosition() const
    {
        // this uses the const get_body()
        return get_body().getPosition() + offset;
    }

    void setPosition(float ppos)
    {
        // this uses the mutable get_body()
        get_body().setPosition(ppos-offset);
    }

You can demonstrate the safety by trying to modify body in a const method:

   void illegal() const
   {
       get_body().setPosition(0); // error: passing ‘const RigidBody’ as ‘this’ argument discards qualifiers
       body.setPosition(0);       // error: passing ‘const RigidBody’ as ‘this’ argument discards qualifiers
   }

};

Demo:

With a RigidBody, the adapter allows all operations; with a const RigidBody, the adapter allows only const operations:

#include <memory>
int main()
{
    {
        RigidBody b;
        std::unique_ptr<Adaptor> a{Adaptor::adapt(b)};
        a->setPosition(15.);
        a->getPosition();
    }

    {
        RigidBody const b;
        std::unique_ptr<const Adaptor> a{Adaptor::adapt(b)};
        a->setPosition(15.);     // error: passing ‘const Adaptor’ as ‘this’ argument discards qualifiers
        a->getPosition();
    }
}