C++ Make function unaccessable in the child class - c++11

Question

I have complex parent class which is being inherited. For now I need just to override a handful of its functions and would like to prevent somehow the possibility to call some non-overridden functions of the parent class in the child object (these functions from parent class would not work properly). I would define them later, if necessary, just want to make it clear, that for now they are not usable, but still inherit some functions to make polymorphism possible. Is it possible to achieve it? Or do I need to change the design?
Here is a small example:
class ParentClass
{
public:
virtual void write() { ... }
virtual void read() { ... }
virtual void calculate() { ... }
};
class ChildClass : public ParentClass
{
public:
void calculate() override { ... }
};
I would like to prevent the possibility to call read or write functions from the ChildClass object, because these functions are complex to define and I don't need them right now. But at the same time I would like to prevent someone from using parent inherited functions in ChildClass. What is important, Parent class is defined in the 3rd party library and I cannot change the parent class.
My (clumsy) idea was to override these functions and throw in them to make it obvious, that they are not accessible, but it is so far from proper design... What could be the proper solution?

Answer 1

One approach when e.g. you want to use part of a class to implement a new class, and you want to use inheritance, but you don't want to expose the whole API of the base class, is to use private inheritance, and then pick and choose what you want to forward.
Here's an example:
#include <stdio.h>
class ParentClass
{
public:
virtual void write() { printf("write"); }
virtual void read() { printf("read"); }
virtual void calculate() { printf("calculate"); }
virtual void other() { printf("other"); }
};
class ChildClass : private ParentClass
{
public:
void calculate() override { printf("new calculate"); }
using ParentClass::other;
};
int main() {
ChildClass c;
c.calculate();
c.other();
}
In godbolt compiler explorer I get this generated assembly (as expected)
.LC0:
.string "new calculate"
.LC1:
.string "other"
main:
sub rsp, 8
mov edi, OFFSET FLAT:.LC0
xor eax, eax
call printf
mov edi, OFFSET FLAT:.LC1
xor eax, eax
call printf
xor eax, eax
add rsp, 8
ret
The using ParentClass::other syntax (for forwarding a function from the base class without changes) is C++11 only, you didn't tag the function c++11 so I don't know if you can use that :), but it is handy

Answer 2

Never had to code something like that and I can't at the moment try this solution out, so take this with a grain of salt.
I think you can declare them as deleted in the child class while keeping them virtual in the base class. This should prompt a compile time error when you try to use it on an object from a child class. That is, in the child class:
void write = deleted;
void read = deleted;
Unfortunately, I'm not 100% sure this would work on a virtual function. If not, you can also try to remove the virtual keyword from those functions in the parent class and use plain overload in the child class with deleted functions as above or even simply declare them without defining them (I prefer deleted functions as they are more explicit). Again, this should prompt a compile time error. You would of course lose the advantage of polymorphism, though.
Let me know if these solutions work.