C++: disallowing virtual function in derived class at compile vs runtime - c++

Question

I have a parent class RO that has a method void setup(const int* p). I need a child class RW to have same method that allows non-const pointers only.
I do it by creating two methods in class RO and disallowing one of them in class RW:
class RO
{
public:
void setup(int* p) { DO SMTH }
virtual void setup (const int* p) { RO::setup( const_cast<int*>(p) ); }
// the rest...
void read() const;
};
class RW : public RO
{
public:
virtual void setup (const int* p) { throw SMTH }
// the rest...
void write();
};
I'd like to be able to disallow RW::setup at compile time when possible. I.e.,
const int* p;
RO* ro = new RW;
ro->setup(p); // Throw at run time, since it can be unknown
// at compile time that ro points to RW and not to RO.
RW* rw = new RW;
rw->f(p); // Disallow this at compile time, since it is
// known at compile time that rw points to RW.
Is there a way to do it?

Answer 1

Use private instead of public inheritance. Make methods of the parent class available in the child class using the using keyword.
Public inheritance is meant for situations where someone who uses a parent class object might as well use a chid class object (look up Liskov substitution principle for details). Your requirement breaks that, so it's no case for public inheritance.

Answer 2

It sounds like class RO has an invariant: "Never modifies *p" (even though it does a sneaky const_cast on p). If class RW violates that invariant, it CANNOT be a subclass of class RO.
I'm guessing what you really want is something more like:
class Readable {
public:
virtual ~Readable();
virtual void read() const = 0;
};
class RO
: public Readable {
public:
void setup(const int* p);
void read() const;
private:
const int* m_p;
};
class RW
: public Readable
{
public:
void setup(int* p);
void read() const;
void write();
private:
int* m_p;
};
And if the followup question is: "What about DRY? Now I have to implement read() twice?", note that you can define a static member function in base class Readable something like:
static void do_read(const int* p);