How can I implement internal abstract member classes in c++? - c++

Question

An abstract class has internal virtual functions.
Can an abstract class have internal virtual classes to be implemented later?
I tried the following:
#include <bits/stdc++.h>
using namespace std;
class C1 {
public:
class Child {
int tmp;
virtual int getint() = 0;
};
virtual Child getChild() = 0;
};
class C2: public C1 {
public:
class Child {
int getint()
{
return 10;
}
} c;
Child getChild()
{
return c;
}
};
int main() { return 0; }
Child is an abstract class which will be overrode in derived classes. And I hope the implemented Child can be used to define a function.
However, I got an error:
invalid abstract return type for member function 'virtual C1::Child C1::getChild()'
Can't I implement an internal abstract class in derived classes, just like implementing a virtual function?

Answer 1

In the present code, class C1::Child and class C2::Child have no inheritance relationship. Hence they are totally unrelated classes. Even if you relate them with inheritance, then also getChild() cannot return Child (value). It can return either Child& (reference) or Child* (pointer) to form a valid virtual methods with covariance. Refer: C++ virtual function return type
Such errors are easily caught by using override specifier available in C++11.
Without knowing the exact context of what you are trying to achieve, the possible code should look like this:
class C1 {
// ... same
virtual Child& getChild() = 0;
// ^^^^^^ reference
};
class C2 : public C1 {
// ^^^^^^ did you miss this?
public:
class Child : public C1::Child {
// ^^^^^^^^^ inheritance
int getint() override { return 10; }
} c;
Child& getChild() override { return c; }
};
Also your below statement seems confusing:
"Child is a abstract class, which will be implemented later,"
Like virtual methods, the classes don't have such runtime relationships.
The best meaning of "implementing later" in the context of class is -- implementing it outside the body of the enclosing class, such as:
class Outer { public: class Inner; };
// ...
class Outer::Inner { ... };

Answer 2

Theoretically, Abstract Classes are used for creating Interfaces. Using Interfaces, clients demand the required functionality. By defining/implementing Interfaces, servers fulfill the client's functionality. Interface/Abstract Class are simply blueprint of requirement/agreement between client and server. The classes which implement the Interface/Abstract Class or fulfills the functionality requirement can be instantiated. So there can be many implementation of the same Interface/Abstract Class. Now in order to access all these different implementation of the same Interface/Abstract Class seamlessly at different point of time, we need a generalized way. And this generalized way is via pointer(*) or reference(&) to the underlying Interface\Abstract Class.
In your code C1::Child is an anAbstract Class or Interface.
So, C1::getChild() can return an implementation of the Interface/Abstract C1::Child. But it cannot return an instance of the Interface/Abstract C1::Child itself as per above theoretical explanation. And hence the error.
Proper way to declare C1::getChild() would be:
virtual C1::Child* getChild() = 0; or
virtual C1::Child& getChild() = 0;
Also, C1::Child can be simply seen as a class inside namespace C1, since class is also a kind of namespace with some restriction.

Answer 3

From your post you seem to be confusing things. I suggest you get a re-read on abstract classes and try some simple examples yourself.
Child is a abstract class, which will be implemented later, And I hope
the implemented Child can be used to define a function.
A pure virtual method (virtual int getint() = 0; in your example) is not meant to be implemented "later". It's meant to be implemented by an override method in a derived class.
E.g. if you have
class Child {
virtual int getint() = 0;
};
you cannot do
class Child {
virtual int getint() { return 10; }
};
nor
int Child::getint() { return 10; }
at a later time.
What you can do is:
class Derived : public Child
{
int getint() override { return 10; }
};