Dieses Verhalten (Aufruf {2} im Code) hat mich (nach etlichen Programmier-Stunden in der Annahme dass es anders wäre) kalt überrascht:
Delphi-Quellcode:
program Project1;
{$APPTYPE CONSOLE}
type
TMyclass = class
class procedure Send ( v: word ); overload;
class procedure Send<T>( v: T ); overload;
end;
var
b: byte = 255;
w: word = 256;
class procedure TMyclass.Send( v: word );
begin
writeln( 'Send' );
end;
class procedure TMyclass.Send<T>( v: T );
begin
writeln( 'Send<T>' );
end;
begin
{1} TMyclass.Send<byte>( b ); // ruft Send<T> auf, okay
{2} TMyclass.Send ( b ); // ruft Send<T> auf, ??
{3} TMyclass.Send<word>( w ); // ruft Send<T> auf naja
{4} TMyclass.Send ( w ); // ruft Send auf, okay
ReadLn
end.
Die Typ-Kompatibilität der generischen Methode Send<T> wird bei der Auswahl der passenden overload-Methode für Aufruf {2} als stärker gewichtet als die Kompatibilität des Aufruf-Parameter-Typs "byte" zum formalen Parameter-Typ "word" des nicht-generischen Send.
Zumindest das Fehlen des konkreten Typs <byte> sollte doch den Compiler dazu bewegen, nur die nicht-generischen overloads in Betracht zu ziehen. Hätte ich so gedacht...
Programmierung allgemein
Zitat
Baum-Darstellung
