Question

For the following code:

class B
{
    public String G() { return "B.G()"; }
}

class D : B
{
    public String G() { return "D.G()"; }
}

class TestCompile
{
    private static String TestG<T>(T b) where T: B 
    {
        return b.G();
    }

    static void Main(string[] args)
    {
        TestG(new D());
    }
}

The result is B.G(), whereas the result of similar C++ code would be D.G().

Why is there this difference?

Answer 1

C# generics are compiled only once: at the time the generic is compiled. (Think about it: C# lets you use List<T> without seeing its implementation.) Here, it sees from the where T: B clause that the parameter is a B, so it calls B.G.

C++ templates are compiled each time they are invoked. When you type TestG<D>(), a brand new copy of TestG is compiled with T = D. At invocation time, the compiler sees that D has its own G method and calls it.

The C++ equivalent of the C# generic would be

template<typename T>
string TestG(T t)
{
    B& b = static_cast<B&>(t); // force `t` into a `B`
    return b.G();
}

The remarks of others regarding the use of virtual apply equally to C# and C++. I’m just explaining why C++ behaves differently from C#.