Wann werden Überladungen auf gelöst?

[Sunray]

Wenn ich eine Methode mit zwei Überladungen definiere, etwa so:

void doSomething(ClassA arg)
{
 // ...
}

doSomething(SubclassOfA arg)
{
 // ...
}

Dann hätten wir da noch eine dritte Funktion, die diese Überladungen in Anspruch nimmt:

void procedure(ClassA input)
{
	// ...
	doSomething(input);
	// ...
}

Jetzt ist zur Übersetzungszeit ja nicht klar, welchen Datentyp input haben wird und somit kann auch nicht eindeutig festgestellt werden, welche der beiden Überladungen denn jetzt hier gilt. Das würde ja heissen, dass die Überladung erst zur Laufzeit aufgelöst werden könnte, wie bei virtuellen Methoden, was dann aber mit einer Geschwindigkeitseinbusse verbunden wäre...

Wie funktioniert das jetzt so bei verschiedenen Sprachen? (C/++, C#, Java, VB.NET?)

Ein Compiler könnte zum Beispiel sagen, dass der input vom Typ ClassA ist und deshalb die erste Überladung in allen Fällen gewählt werden würde...

 

[Matthias Reitinger]

Ich kann jetzt nur für C++ sprechen: der Typ von input in procedure ist ja zur Kompilierzeit klar definiert (und zwar ClassA). Somit wird auch zur Kompilierzeit bestimmt, dass die Überladung von doSomething mit dem Parameter ClassA aufgerufen wird.

 

[hpvw]

Ebenso in Java:

package overload;

/**
 * 
 * @author hpvw
 */
public class Test {
    public void doSomething(ClassA arg) {
        System.out.println("ClassA:"+arg.getClass());        
    }
    
    public void doSomething(SubclassOfA arg) {
        System.out.println("SubclassOfA:"+arg.getClass());        
    }

    public static void main(String[] args) {
        Test t = new Test();
        ClassA cA = new ClassA();
        ClassA cA2 = new SubclassOfA();
        SubclassOfA sOA = new SubclassOfA();
        t.doSomething(cA);
        t.doSomething(cA2);
        t.doSomething(sOA);
    }
}
/* Output
ClassA:class overload.ClassA
ClassA:class overload.SubclassOfA
SubclassOfA:class overload.SubclassOfA
*/

 

[Sunray]

Dann nehme ich mal an, dass C# und VB Compiler das ebenso handhaben.
Gibt es dabei einen Unterschied, wenn die Methode doSomething virtuell ist?