Template cast to super class - c++

Question

I want to be able to pass functions with an object of class I as parameter, where I inherits from D, to FD constructor::
class D {}; class I: public D {};
FD(std::function<void(D*)> f): _f(f) {}
void test(I*) { std::cout << "Success" << std::endl; }
FD fd(test); fd.call();
As I have been researching I should implement a type conversion, but I do not know a clean way and did not find answers addressing type conversions appliable to my case.
Here is the full code:
#include <functional>
#include <iostream>
class D {}; class I: public D {};
class FD {
protected:
std::function<void(D*)> _f;
public:
explicit FD(std::function<void(D*)> f): _f(f) {}
void call() { _f(0); }
};
void test(I*) { std::cout << "Success" << std::endl; }
int main () {
FD fd(test); fd.call();
}
I get:
test.cpp: In function ‘int main()’:
test.cpp:17:13: error: no matching function for call to ‘FD::FD(void (&)(I*))’
FD fd(test); fd.call();
^
test.cpp:10:14: note: candidate: FD::FD(std::function<void(D*)>)
explicit FD(std::function<void(D*)> f): _f(f) {}
^~
test.cpp:10:14: note: no known conversion for argument 1 from ‘void(I*)’ to ‘std::function<void(D*)>’
I have also tried using int and double:
#include <functional>
#include <iostream>
class FD {
protected:
std::function<void(double)> _f;
public:
explicit FD(std::function<void(double)> f): _f(f) {}
void call() { _f(0); }
};
void test(int v) { std::cout << "Success" << std::endl; }
int main () {
FD fd(test); fd.call();
}
With output:
Success

Answer 1

It's possible to explain the reason for the compilation error in excruciating technical detail, and why you cannot do what you want to do, in C++, but perhaps this fundamental reason will be clear to you if you consider a very simple thought experiment:
std::function<void(D*)> f;
You surely understand that this callable object can be called using a pointer to any subclass of D. You might have some other class called J that also inherits from D, and so this is perfectly acceptable:
class J : public D {};
J j;
f(&j);
But you are attempting to do here is construct your std::function using a pointer to a function that takes only I * as a parameter:
void test(I*)
If what you were attempting to do was possible, then this will mean that this test() function can be called, via the std::function<void (D*)> object, using a pointer to J, instead of I. Fail. This is, of course, is not allowed in C++. If the only relationship between two classes is that they all have the same parent class, you simply cannot convert a pointer to one of them to a pointer to the other one. C++ does not work this way.
And the reason why your 2nd example, with ints and doubles work, is because ints and doubles can be converted to each other. The same is not true with pointers to two random classes. A pointer to a class can be converted to a pointer to a different class only in certain, well-defined cases. What you want is not allowed in C++.
The only thing that can happen here is the test() function taking a D * as a parameter, crossing its fingers and attempting to dynamic_cast it to an I * (assuming that D meets the requirements for a dynamic-castable class). And then you will have to decide what happens when this conversion fails.

Answer 2

Of course, you can do the cast like this: FD fd(reinterpret_cast<void(*)(D*)>(test)); but this is UB.
The error is clear - you can't implicitly cast D* to I*. This violates polymorphism.
Are you sure you are not mixing up I and D?
UPD:
I assume downvoting this post means it is not clear. I will try to explain:
Imagine the following:
class D
{
public:
void (*ok)() = +[] { std::cout << "OK"; };
};
class I: public D
{
public:
void (*not_ok)() = ok;
};
ok() can be accesed from D instance while not_ok() cannot. Now you want to call your function taking pointer to I. But that means your function can call not_ok() which is not valid for pointer to D:
void test(I* i)
{
i->ok();
i->not_ok();
}
With raw pointers you can try this:
class FD {
protected:
std::function<void(D*)> _f;
public:
explicit FD(void(*f)(I*)) : _f(reinterpret_cast<void(*)(D*)>(f))
{
}
void call() { _f(new I); }
};
It will print OKOK. But if you replacenew I with new D it will fail on not_ok() call
This is why C++ doesn't allow to implicitly cast pointers (while you still can implicitly cast int to double).
Even if you want to 'hack' your code, C++ has no global type conversion rules. Also, you can't get raw pointer from std::function, therefore, there is no way to do this.