Virtual function input Argument type [duplicate] - c++

Question

This question already has answers here:
"Overloading" pure virtual function with different set of arguments
(5 answers)
Closed 2 years ago.
I am trying to understand inheritance and polymorphism. When I run this :
#include<iostream>
using namespace std;
class Base
{
int x;
public:
virtual Base* fun() = 0;
int getX() { return x; }
};
// This class inherits from Base and implements fun()
class Derived: public Base
{
public:
int y;
Derived* fun() {
Derived *d = new Derived;
d->y = 2;
return d;
}
};
int main(void)
{
Derived d;
Derived *p = d.fun();
cout<< p->y;
}
This works fine as it is legal for a derived class to override a virtual function using a different return type as long as the return type is covariant with the original return type
But what if the virtual function contain the input argument of type Base*. Like :
#include<iostream>
using namespace std;
class Base
{
int x;
public:
virtual Base* fun(Base * t) = 0;
int getX() { return x; }
};
// This class inherits from Base and implements fun()
class Derived: public Base
{
public:
int y;
Derived* fun(Derived *t) {
Derived *d = new Derived;
d->y = t->y;
return d;
}
};
int main(void)
{
Derived d;
Derived *p = d.fun();
cout<< p->y;
}
This is throwing error error: invalid new-expression of abstract class type ‘Derived’ Derived *d = new Derived; which I understand it means that compiler is not recognising the implementation of the virtual function and considering the class ``Derived``` as abstract.
So how can we override virtual function of this type ??
I tried to search it , but didn't find any reference. If similar question exists , let me know.
Thanks

Answer 1

If I needed this in my own code. I'd write the new derived class like this:
// This class inherits from Base and implements fun()
class Derived: public Base
{
public:
int y;
Derived* fun(Base *t) {
Derived *d = new Derived;
Derived* input = dynamic_cast<Derived *>(t);
ASSERT(input); // Cause the debug version to throw an exception so the error can be debugged
if(input)
d->y = t->y;
else
d->y = 0; // Or the default of your choice.
return d;
}
};
This introduces a potential runtime error if the base type passed in is not the correct derived type. But I don't see a way to avoid it.
The other options I see are use templates. Where the derived type requires the derived type to be passed in. Or simply create a new function that takes the derived type as input and also overrides fun(Base *t);

Answer 2

using namespace std;
template <class T>
class Base
{
int x;
public:
virtual T* fun(T* t) = 0;
int getX() { return x; }
};
class Derived : public Base<Derived>
{
public:
int y;
Derived() { y = 0; }
Derived* fun(Derived* t) {
Derived *d = new Derived;
d->y = t->y;
return d;
}
};
int main(int argc, const char* argv[])
{
Derived *d = new Derived;
Derived * p = d->fun(d);
cout << p->y;
return 0;
}
test in visual studio 2019.