root/trunk/docsrc/template-comparison.dd

Ddoc

$(COMMUNITY Template Comparison,

$(P C++ pioneered templates and template metaprogramming, and continues
to improve on it with C++0x.
The D programming language is the first to comprehensively reengineer
templates based on the C++ experience.
Since C++0x is not a ratified standard yet, proposed changes to C++
are subject to change.)

    <table border=2 cellpadding=4 cellspacing=0 class="comp">
    <caption>Template Comparison Table</caption>

    <thead>
    $(TR
    $(TH Feature)
    $(TH D)
    $(TH C++98)
    $(TH C++0x)
    )
    </thead>

    <tbody>

    $(TR
    $(TD Argument list delineation)
    $(TD Uses !( ), as in Foo!(int))
    $(TD Uses &lt; &gt; as in Foo&lt;int&gt;)
    $(TD No change)
    )

    $(TR
    $(TD Class Templates)
    $(TD Yes:
---
class Foo(T)
{
  T x;
}
---
)
    $(TD Yes:
$(CPPCODE2
template&lt;class T&gt;
  class Foo
{
  T x;
};
)
)
    $(TD No change)
    )

    $(TR
    $(TD Function Templates)
    $(TD Yes:
---
T foo(T)(T i)
{
  ...
}
---
)
    $(TD Yes:
$(CPPCODE2
template&lt;class T&gt;
  T foo(T i)
{
  ...
}
)
)
    $(TD No change)
    )

    $(TR
    $(TD Member Templates)
    $(TD Yes)
    $(TD Yes)
    $(TD No change)
    )

    $(TR
    $(TD Constructor Templates)
    $(TD No)
    $(TD Yes)
    $(TD No change)
    )

    $(TR
    $(TD Parameterize any Declaration)
    $(TD Yes, classes, functions, typedefs,
    variables, enums, etc. can be parameterized,
    such as this variable:
---
template Foo(T)
{
  static T* p;
}
---
)
    $(TD No, only classes and functions)
    $(TD No change)
    )

    $(TR
    $(TD Template Typedefs: Create an alias that binds to some but not all
    of the template parameters)
    $(TD Yes:
---
class Foo(T, U) { }
template MyFoo(T)
{
  alias Foo!(T, int) MyFoo;
}
MyFoo!(uint) f;
---
)
    $(TD No)
    $(TD Yes:
$(CPPCODE2
template&lt;class T, class U&gt; class Foo { };
template&lt;class T&gt; using MyFoo = Foo&lt;T, int&gt;;
MyFoo&lt;unsigned&gt; f;
)
)
    )


    $(TR
    $(TD Sequence Constructors)
    $(TD No)
    $(TD No)
    $(TD Yes:
$(CPPCODE2
Foo&lt;double&gt; f = { 1.2, 3, 6.8 };
)
)
    )

    $(TR
    $(TD Concepts)
$(V1
    $(TD No, but much the same effect can be achieved with
     $(LINK2 version.html#staticif, static if) and
     $(LINK2 version.html#StaticAssert, static asserts))
)
$(V2
    $(TD Yes: $(LINK2 cpp0x.html#concepts, Constraints))
)
    $(TD No)
    $(TD Yes: $(LINK2 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1849.pdf, Concepts for C++0x N1849))
    )


    $(TR
    $(TD Recursive Templates)
    $(TD Yes:
---
template factorial(int n)
{
  const factorial =
     n * factorial!(n-1);
}
template factorial(int n : 1)
{
  const factorial = 1;
}
---
)
    $(TD Yes:
$(CPPCODE2
template&lt;int n&gt; class factorial
{
  public:
    enum
    {
      result =
         n * factorial&lt;n-1&gt;::result
    }; 
};
template&lt;&gt; class factorial&lt;1&gt;
{
  public:
    enum { result = 1 };
};
)
)
    $(TD No change)
    )

    $(TR
    $(TD Conditional Compilation based on
    Template Arguments)
    $(TD Yes:
---
template factorial(int n)
{
  static if (n == 1)
    const factorial = 1;
  else
    const factorial =
       n * factorial!(n-1);
}
---
)
    $(TD No:
$(CPPCODE2
template&lt;int n&gt; class factorial
{
  public:
    enum
    {
#if (n == 1) // $(ERROR)
      result = 1;
#else
      result =
         n * factorial&lt;n-1&gt;::result
#endif
    }; 
};
)
)
    $(TD No change)
    )

    $(TR
    $(TD Template Declarations (with no definition))
    $(TD No)
    $(TD Yes:
$(CPPCODE2
template&lt;class T&gt;
  class Foo;
)
)
    $(TD No change)
    )

    $(TR
    $(TD Grouping templates with the same parameters together)
    $(TD Yes:
---
template Foo(T, U)
{
  class Bar { ... }
  T foo(T t, U u) { ... }
}
Foo!(int,long).Bar b;
return Foo!(char,int).foo('c',3);
---
)
    $(TD No, each must be separate:
$(CPPCODE2
template&lt;class T, class U&gt;
  class Foo_Bar { ... };
template&lt;class T, class U&gt;
  T Foo_foo(T t, U u) { ... };
Foo_Bar&lt;int,long&gt; b;
return Foo_foo&lt;char,int&gt('c',3);
)
)
    $(TD No change)
    )

    $(TR
    $(TD Compile time execution of functions)
    $(TD $(LINK2 function.html#interpretation, Yes):
---
int factorial(int i)
{ if (i == 0)
    return 1;
  else
    return i * factorial(i - 1);
}
static f = factorial(6);
---
    )
    $(TD No)
    $(TD Named constant expressions with parameters:
       $(LINK2 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1972.pdf, Generalized Constant Expressions N1972))
    )

    $(TR
    $(TH Parameters)
    $(TH D)
    $(TH C++98)
    $(TH C++0x)
    )

    $(TR
    $(TD Type Parameters)
    $(TD Yes:
---
class Foo(T)
{
  T x;
}
Foo!(int) f;
---
)
    $(TD Yes:
$(CPPCODE2
template&lt;class T&gt;
  class Foo
{
  T x;
};
Foo&lt;int&gt; f;
)
)
    $(TD No change)
    )

    $(TR
    $(TD Integral Parameters)
    $(TD Yes:
---
void foo(int i)()
{
  int v = i;
}
---
)
    $(TD Yes:
$(CPPCODE2
template&lt;int i&gt;
    void foo()
{
  int v = i;
}
)
)
    $(TD No change)
    )

    $(TR
    $(TD Pointer Parameters)
    $(TD Yes, a pointer to object or function)
    $(TD Yes, a pointer to object or function)
    $(TD No change)
    )

    $(TR
    $(TD Reference Parameters)
    $(TD No, D does not have a general reference type)
    $(TD Yes:
$(CPPCODE2
template&lt;double& D&gt;
    void foo()
{
  double y = D;
}
)
)
    $(TD No change)
    )

    $(TR
    $(TD Pointer to Member Parameters)
    $(TD No, D does not have pointers to members, it has
      $(LINK2 type.html#delegates, delegates),
      which can be used as parameters)
    $(TD Yes)
    $(TD No change)
    )

    $(TR
    $(TD Template Template Parameters)
    $(TD Yes:
---
class Foo(T, alias C)
{
  C!(T) x;
}
---
)
    $(TD Yes:
$(CPPCODE2
template&lt;class T,
         template&lt;class U&gt; class C&gt;
    class Foo
{
  C&lt;T&gt; x;
};
)
)
    $(TD No change)
    )

    $(TR
    $(TD Alias Parameters)
    $(TD Yes, any symbol can be passed to a template as an alias:
---
void bar(int);
void bar(double);
void foo(T, alias S)(T t)
{
  S(t);
}
// calls bar(double)
foo!(double, bar)(1);
---
)
    $(TD No)
    $(TD No change)
    )

    $(TR
    $(TD Floating Point Parameters)
    $(TD Yes:
---
class Foo(double D)
{
  double x = D;
}
...
Foo!(1.6) F;
---
)
    $(TD No)
    $(TD No change)
    )

    $(TR
    $(TD String Parameters)
    $(TD Yes:
---
void foo(char[] format)(int i)
{
  writefln(format, i);
}
...
foo!("i = %s")(3);
---
)
    $(TD No)
    $(TD No change)
    )

    $(TR
    $(TD Local Class Parameters)
    $(TD Yes)
    $(TD No)
    $(TD Issue N1945)
    )

    $(TR
    $(TD Local Variable Parameters)
    $(TD Yes)
    $(TD No)
    $(TD No change)
    )

    $(TR
    $(TD Parameter Default Values)
    $(TD Yes:
---
class Foo(T = int)
{
  T x;
}
---
)
    $(TD Yes:
$(CPPCODE2
template&lt;class T = int&gt;
  class Foo
{
  T x;
};
)
)
    $(TD No change)
    )

    $(TR
    $(TD Variadic Parameters)
    $(TD Yes, $(LINK2 variadic-function-templates.html, Variadic Templates):
---
void print(A...)(A a)
{
    foreach(t; a)
    writefln(t);
}
---
)
    $(TD No)
    $(TD $(LINK2 http://www.osl.iu.edu/~dgregor/cpp/variadic-templates.pdf, Variadic Templates N2080))
    )

    $(TR
    $(TH Specializations)
    $(TH D)
    $(TH C++98)
    $(TH C++0x)
    )

    $(TR
    $(TD Explicit Specialization)
    $(TD Yes:
---
class Foo(T : int)
{
  T x;
}
---
)
    $(TD Yes:
$(CPPCODE2
template&lt;&gt;
  class Foo&lt;int&gt;
{
  int x;
};
)
)
    $(TD No change)
    )

    $(TR
    $(TD Partial Specialization)
    $(TD Yes:
---
class Foo(T : T*, U)
{
  T x;
}
---
)
    $(TD Yes:
$(CPPCODE2
template&lt;class T, class U&gt;
  class Foo&lt;T*, U&gt;
{
  T x;
};
)
)
    $(TD No change)
    )

    $(TR
    $(TD Partial specialization derived from multiple parameters)
    $(TD Yes:
---
class Foo(T : Bar!(T, U), U)
{
  ...
}
---
)
    $(TD Yes:
$(CPPCODE2
template&lt;class T, class U&gt;
    class Foo&lt; Bar&lt;T,U&gt; &gt;
{
  ...
};
)
)
    $(TD No change)
    )

    $(TR
    $(TD Can specializations exist without a primary template?)
    $(TD Yes)
    $(TD No)
    $(TD No change)
    )

    $(TR
    $(TH Other)
    $(TH D)
    $(TH C++98)
    $(TH C++0x)
    )

    $(TR
    $(TD Exported Templates)
    $(TD Yes, it falls out as a natural consequence of modules)
    $(TD Yes, though only in compilers based on EDG's front end)
    $(TD No change)
    )

    $(TR
    $(TD $(SFINAE))
    $(TD Yes)
    $(TD Yes)
    $(TD No change)
    )

    $(TR
    $(TD Parse Template Definition Bodies before Instantiation)
    $(TD Yes)
    $(TD Not required by Standard, but some implementations do)
    $(TD No change)
    )

    $(TR
    $(TD Overloading Function Templates with Functions)
    $(TD No, but the equivalent can be done with explicitly specialized
    templates:
---
void foo(T)(T t) { }
void foo(T:int)(int t) { }
---
)
    $(TD Yes:
$(CPPCODE2
template&lt;class T&gt;
  void foo(T i) { }
void foo(int t) { }
)
)
    $(TD No change)
    )

    $(TR
    $(TD Implicit Function Template Instantiation)
    $(TD Yes)
    $(TD Yes)
    $(TD No change)
    )

    $(TR
    $(TD Templates can be evaluated in scope
      of instantiation rather than definition)
    $(TD Yes, $(LINK2 mixin.html, Mixins))
    $(TD No, but can be faked using macros)
    $(TD No change)
    )

    $(TR
    $(TH Parsing Idiosyncracies)
    $(TH D)
    $(TH C++98)
    $(TH C++0x)
    )



    $(TR
    $(TD Context-Free Grammar)
    $(TD Yes:
---
class Foo!(int i)
{
   ...
}
Foo!(3 $(B >) 4) f;
---
)
    $(TD No:
$(CPPCODE2
template&lt;int i&gt; class Foo
{
   ...
};
Foo&lt;3 $(B &gt;) 4&gt; f; // $(ERROR)
)
)
    $(TD No change)
    )


    $(TR
    $(TD Distinguish template arguments from other operators)
    $(TD Yes:
---
class Foo!(T)
{
   ...
}
class Bar!(int i)
{
   ...
}
Foo!(Bar!(1)) x1;
---
)
    $(TD No:
$(CPPCODE2
template&lt;class T&gt; class Foo
{
   ...
};
template&lt;int i&gt; class Bar
{
   ...
};
Foo&lt;Bar&lt;1&gt;&gt; x1; // $(ERROR)
Foo&lt;Bar&lt;1&gt; &gt; x2;
)
)
    $(TD Partially fixed by
    $(LINK2 http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1757.html, Right Angle Brackets N1757)
    )

    )


    $(TR
    $(TD Redeclaration of Template Parameter)
    $(TD Yes:
---
class Foo(T)
{
  int T;
  void foo()
  {
    int T;
  }
}
---
)
    $(TD No:
$(CPPCODE2
template&lt;class T&gt;
  class Foo
{
  int T; // $(ERROR)
  void foo()
  {
    int T; // $(ERROR)
  }
};
)
)
    $(TD No change)
    )

    $(TR
    $(TD Dependent Base Class Lookup)
    $(TD Yes:
---
class Foo(T)
{
  typedef int $(B A);
}
class Bar(T) : Foo(T)
{
  $(B A) x;
}
---
)
    $(TD No:
$(CPPCODE2
template&lt;class T&gt;
  class Foo
{
  public:
    typedef int $(B A);
};
template&lt;class T&gt;
  class Bar : Foo&lt;T&gt;
{
  public:
    $(B A) x; // $(ERROR)
};
)
)
    $(TD No change)
    )




    $(TR
    $(TD Forward Referencing)
    $(TD Yes:
---
int $(B g)(void *);

class Foo(T)
{
  int foo()
  {
    return $(B g)(1);
  }
}

int $(B g)(int i);
---
)
    $(TD No:
$(CPPCODE2
int $(B g)(void *);

template&lt;class T&gt;
  class Foo
{
  int foo()
  {
    return $(B g)(1); // $(ERROR)
  }
};

int $(B g)(int i);
)
)
    $(TD No change)
    )


    $(TR
    $(TD Member templates parseable without hints)
    $(TD Yes:
---
class Foo
{
    Foo bar!(int I)();
}
void abd(T)(T f)
{
  T f1 = f.bar!(3)();
}
---
)
    $(TD No:
$(CPPCODE2
class Foo
{
  public:
    template&lt;int&gt; Foo *bar();
};
template&lt;class T&gt; void abc(T *f)
{
  T *f1 = f-&gt;bar&lt;3&gt;(); // $(ERROR)
  T *f2 = f-&gt;$(B template) bar&lt;3&gt;();
}
)
)
    $(TD No change)
    )


    $(TR
    $(TD Dependent type members parseable without hints)
    $(TD Yes:
---
class Foo(T)
{
  T.A* a1;
}
---
)
    $(TD No:
$(CPPCODE2
template<class T> class Foo
{
  public:
    T::A *a1; // $(ERROR)
    $(B typename) T::A *a2;
};
)
)
    $(TD No change)
    )

    </tbody>
    </table>

)

Macros:
    TITLE=Template Comparison
    WIKI=TemplateComparison
    NO=<td class="compNo">No</td>
    NO1=<td class="compNo"><a href="$1">No</a></td>
    YES=<td class="compYes">Yes</td>
    YES1=<td class="compYes"><a href="$1">Yes</a></td>
    D_CODE = <pre class="d_code2">$0</pre>
    CPPCODE2 = <pre class="cppcode2">$0</pre>
    ERROR = $(RED $(B error))
META_KEYWORDS=D Programming Language, template metaprogramming,
variadic templates, type deduction, dependent base class
META_DESCRIPTION=Comparison of templates between the
D programming language, C++, and C++0x