This is an absurdly noobish question, but here goes. I'm
learning D (I'm already reasonably comfortable with C and
Objective-C, so compiled languages are not new to me), and I
can't figure out why this super simple operation doesn't work.
I have a parent and a child class, and while implicit casting
from child to parent works (function which takes parent will
accept instance of child), it does not work with pointers (and
yes, I understand that because objects are reference types a
MyObject* is really a pointer to a pointer since a MyObject is a
pointer). A function that takes a Parent* as an argument will
not accept &myChild in its place without an explicit
cast(Parent*)&myChild.
I feel like there's some fundamental property of the D
implementation that I'm not getting. I was under the impression
an subtype's instance could *always always always* be put in
place of an instance of the super type. Why are pointers an
exception?
class Parent {}
class Child : Parent {}
void myFunc(Parent* obj) {
writeln("got ", obj);
}
void main() {
Child myChild = new Child();
myFunc(&myChild);
}
referenceTest.d(11): Error: function referenceTest.myFunc
(Parent* obj) is not callable using argument types (Child*)
referenceTest.d(11): Error: cannot implicitly convert expression
(& myChild) of type Child* to Parent*
