On 15.03.2010 3:42, Walter Bright wrote:
Bane wrote:
======= C++ =========
template<class T> class Foo
{
T member;
};
======= D ===========
class Foo(T)
{
T member;
}
=====================

Yes, it looks like a trivial change, and perhaps it is. But it makes
a world of difference, because it now looks like something I do get -
a parameter list to something.

Fucking beautiful. I finally get it.


Ya know what's funny? I had to go and double check that the C++ syntax
above was correct. Didn't have to do that for D.

Though I love D's templates:

1. People tend to throw them in where a runtime solution would suffice. One example is an overload of 'clear' in the D runtime:

void clear(T)(T obj) if (is(T == class))
{
    auto defaultCtor =
        cast(void function(Object)) obj.classinfo.defaultConstructor;
    version(none) // enforce isn't available in druntime
        _enforce(defaultCtor || (obj.classinfo.flags & 8) == 0);
    immutable size = obj.classinfo.init.length;
    static if (is(typeof(obj.__dtor())))
    {
        obj.__dtor();
    }
    auto buf = (cast(void*) obj)[0 .. size];
    buf[] = obj.classinfo.init;
    if (defaultCtor)
        defaultCtor(obj);
}

Since the function uses runtime information (except for the destructor), it is absolutely unnecessary to instantiate the template for each concrete class type. A more severe problem with the code above, unrelated to templates, is that base class destructors are not called.

Here is a non-template implementation that should fix the problems (it is a template but only formally):

void clear(Dummy = void)(Object obj)
{
    auto ci = obj.classinfo;
    auto defaultCtor =
        cast(void function(Object)) ci.defaultConstructor;
    version(none) // enforce isn't available in druntime
        _enforce(defaultCtor || (ci.flags & 8) == 0);
    immutable size = ci.init.length;

    auto ci2 = ci;
    do
    {
        auto dtor = cast(void function(Object))ci2.destructor;;
        if (dtor)
            dtor(obj);
        ci2 = ci2.base;
    } while (ci2)

    auto buf = (cast(void*) obj)[0 .. size];
    buf[] = ci.init;
    if (defaultCtor)
        defaultCtor(obj);
}

BTW, I do think that base class destructor calls not compiled directly into derived class destructors is a mistake.

2. Templates impose functional style on programmers (see Bartosz's rant at http://bartoszmilewski.wordpress.com/2009/10/21/what-does-haskell-have-to-do-with-c/).

Reply via email to