Am 21.02.2011 11:18, schrieb useo:
Hey guys,
I've a small problem implementing multiple opCall()-methods. At first, I've the
following interface:
interface Invoker {
void opCall(uint i);
}
... and an abstract class which inherits from the Invoker-interface like the
following:
abstract class AbstractInvoker : Invoker {
private int myInt;
override void opCall(uint i) { /** do nothing */ }
In an abstract class you can just leave this out. The inheriting class
will then be checked to implement this.
void opCall() {
opCall(myInt);
}
}
I know... I can remove the opCall(uint i) from the interface, but it's needed
for some other classes which implements this method. For
those classes the opCall(uint i)-method is needed.
But... when I now declare a class like this:
class InvokableClass : AbstractInvoker {
override void opCall(uint i) {
// do something
}
}
and do the following:
void main(string[] args) {
InvokableClass() ic = new InvokeableClass();
ic();
}
I always get the following errors:
Error: function InvokableClass.opCall (uint i) is not callable using argument
types ().
Error: expected 1 function arguments, not 0
But I think opCall() is implemented in the abstract class and should be
callable using opCall() instead using opCall(uint i)?
Overriding one opCall shadows all other opCalls inherited from the base
class. This behaviour is like with any method. Write:
override void opCall() {
super.opCall();
}
to forward to the base class method.
AFAIK it's an anti-hijacking machanism.
