从http://www.digitalmars.com/d/cpptod.html摘录
1、构造函数：
c++:
1 class Foo
2 {
3 Foo(int x);
4 };
d:
1 class Foo
2 {
3 this(int x) { }
4 }
2、基类初始化
c++:
1 class A { A() {
} };
2 class B : A
3 {
4 B(int x)
5 : A() // call base constructor
6 {
7 }
8 }; d:
1 class A { this() { } }
2 class B : A
3 {
4 this(int x)
5 {
6 super(); // call base constructor
7
8 }
9 } d还支持构造函数里面调用另一个构造函数，当然不能交叉调用，否则会死循环，d编译器会阻止你这么做。
1 class A
2 { int a = 7;
3 int b;
4 this() { b = foo(); }
5 this(int x)
6 {
7 this();
8 a = x;
9 }
10 }
上面的a=7会在构造函数内其它代码调用之前执行。
3、结构：
c++:
1 #include <string.h>
2
3 struct A x, y;
4
5 inline bool operator==(const A& x, const A& y)
6 {
7 return (memcmp(&x, &y, sizeof(struct A)) == 0);
8 }
9
10 if (x == y)
11 d:
1 A x, y;
2
3 if (x == y)
4
5
4、typedef定义新类型：
c:
1 #define HANDLE_INIT ((Handle)(-1))
2 typedef void *Handle;
3 void foo(void *);
4 void bar(Handle);
5
6 Handle h = HANDLE_INIT;
7 foo(h); // coding bug not caught
8 bar(h); // ok
c++:（加入自动初始化）
1 #define HANDLE_INIT ((void *)(-1))
2 struct Handle
3 { void *ptr;
4
5 // default initializer
6 Handle() { ptr = HANDLE_INIT; }
7
8 Handle(int i) { ptr = (void *)i; }
9
10 // conversion to underlying type
11 operator void*() { return ptr; }
12 };
13 void bar(Handle);
14
15 Handle h;
16 bar(h);
17 h = func();
18 if (h != HANDLE_INIT)
19 d:
1 typedef void *Handle = cast(void *)-1;
2 void bar(Handle);
3
4 Handle h;
5 bar(h);
6 h = func();
7 if (h != Handle.init)
5、友元：
c++:
1 class A
2 {
3 private:
4 int a;
5
6 public:
7 int foo(B *j);
8 friend class B;
9 friend int abc(A *);
10 };
11
12 class B
13 {
14 private:
15 int b;
16
17 public:
18 int bar(A *j);
19 friend class A;
20 };
21
22 int A::foo(B *j) { return j->b; }
23 int B::bar(A *j) { return j->a; }
24
25 int abc(A *p) { return p->a; }
d:（d语言中，同一模块隐含友元声明）
1 module X;
2
3 class A
4 {
5 private:
6 static int a;
7
8 public:
9 int foo(B j) { return j.b; }
10 }
11
12 class B
13 {
14 private:
15 static int b;
16
17 public:
18 int bar(A j) { return j.a; }
19 }
20
21 int abc(A p) { return p.a; }
6、操作符重载：
c++:
1 struct A
2 {
3 int operator < (int i);
4 int operator <= (int i);
5 int operator > (int i);
6 int operator >= (int i);
7 };
8
9 int operator < (int i, A &a) { return a > i; }
10 int operator <= (int i, A &a) { return a >= i; }
11 int operator > (int i, A &a) { return a < i; }
12 int operator >= (int i, A &a) { return a <= i; }
d:
1 struct A
2 {
3 int opCmp(int i);
4 }
7、命名空间以及using声明：
c++:
1 namespace Foo
2 {
3 int x;
4 }
5 using Foo::x;
d:
1 /** Module Foo.d **/
2 module Foo;
3 int x;
1 /** Another module **/
2 import Foo;
3 alias Foo.x x;
8、RAII（资源获得即初始化）
c++:
class File
{ Handle *h;
~File()
{
h->release();
}
};
d:（使用auto关键字）
auto class File
{ Handle h;
~this()
{
h.release();
}
}
void test()
{
if ()
{ auto File f = new File();
} // f.~this() gets run at closing brace, even if
// scope was exited via a thrown exception
}
9、属性：
c++:
1 class Abc
2 {
3 public:
4 void setProperty(int newproperty) { property = newproperty; }
5 int getProperty() { return property; }
6
7 private:
8 int property;
9 };
10
11 Abc a;
12 a.setProperty(3);
13 int x = a.getProperty();
d:
1 class Abc
2 {
3 // set
4 void property(int newproperty) { myprop = newproperty; }
5
6 // get
7 int property() { return myprop; }
8
9 private:
10 int myprop;
11 }
12
13 Abc a;
14 a.property = 3; // equivalent to a.property(3)
15 int x = a.property; // equivalent to int x = a.property()
10、递归模板：
c++:（经典的阶乘模板）
1 template<int n> class factorial
2 {
3 public:
4 enum { result = n * factorial<n - 1>::result };
5 };
6
7 template<> class factorial<1>
8 {
9 public:
10 enum { result = 1 };
11 };
12
13 void test()
14 {
15 printf("%d\n", factorial<4>::result); // prints 24
16 }
d:（d语言中，实例化模板时，与模板名同名的类、函数、变量等会自动成为实例化模板的值，说着不太顺，大致是这么个意思。。）
1 template factorial(int n)
2 {
3 enum { factorial = n * .factorial!(n-1) }
4 }
5
6 template factorial(int n : 1)
7 {
8 enum { factorial = 1 }
9 }
10
11 void test()
12 {
13 printf("%d\n", factorial!(4)); // prints 24
14 }
11、元编程：
c++:
1 #include <limits.h>
2
3 template< int nbits > struct Integer
4 {
5 typedef Integer< nbits + 1 > :: int_type int_type ;
6 } ;
7
8 struct Integer< 8 >
9 {
10 typedef signed char int_type ;
11 } ;
12
13 struct Integer< 16 >
14 {
15 typedef short int_type ;
16 } ;
17
18 struct Integer< 32 >
19 {
20 typedef int int_type ;
21 } ;
22
23 struct Integer< 64 >
24 {
25 typedef long long int_type ;
26 } ;
27
28 // If the required size is not supported, the metaprogram
29 // will increase the counter until an internal error is
30 // signaled, or INT_MAX is reached. The INT_MAX
31 // specialization does not define a int_type, so a
32 // compiling error is always generated
33 struct Integer< INT_MAX >
34 {
35 } ;
36
37 // A bit of syntactic sugar
38 #define Integer( nbits ) Integer< nbits > :: int_type
39
40 #include <stdio.h>
41
42 int main()
43 {
44 Integer( 8 ) i ;
45 Integer( 16 ) j ;
46 Integer( 29 ) k ;
47
48 Integer( 64 ) l ;
49 printf("%d %d %d %d\n",
50 sizeof(i), sizeof(j), sizeof(k), sizeof(l));
51 return 0 ;
52 }
boost:
1 #include <boost/mpl/if.hpp>
2 #include <boost/mpl/assert.hpp>
3
4 template <int nbits> struct Integer
5 : mpl::if_c<(nbits <= 8), signed char
6 , mpl::if_c<(nbits <= 16), short
7 , mpl::if_c<(nbits <= 32), long
8 , long long>::type >::type >
9 {
10 BOOST_MPL_ASSERT_RELATION(nbits, <=, 64);
11 }
12
13 #include <stdio.h>
14
15 int main()
16 {
17 Integer< 8 > i ;
18 Integer< 16 > j ;
19 Integer< 29 > k ;
20 Integer< 64 > l ;
21 printf("%d %d %d %d\n",
22 sizeof(i), sizeof(j), sizeof(k), sizeof(l));
23 return 0 ;
24 }
d:
1 template Integer(int nbits)
2 {
3 static if (nbits <= 8)
4 alias byte Integer;
5 else static if (nbits <= 16)
6 alias short Integer;
7 else static if (nbits <= 32)
8 alias int Integer;
9 else static if (nbits <= 64)
10 alias long Integer;
11 else
12 static assert(0);
13 }
14
15 int main()
16 {
17 Integer!(8) i ;
18 Integer!(16) j ;
19 Integer!(29) k ;
20 Integer!(64) l ;
21 printf("%d %d %d %d\n",
22 i.sizeof, j.sizeof, k.sizeof, l.sizeof);
23 return 0;
24 }
12、type traits（类型萃取）：
c++:（也算是经典的，函数类型判断）
template<typename T> class IsFunctionT
{
private:
typedef char One;
typedef struct { char a[2]; } Two;
template<typename U> static One test();
template<typename U> static Two test(U (*)[1]);
public:
enum { Yes = sizeof(IsFunctionT<T>::test<T>(0)) == 1 };
};
void test()
{
typedef int (fp)(int);
assert(IsFunctionT<fp>::Yes == 1);
} d:
1 template IsFunctionT(T)
2 {
3 static if ( is(T[]) )
4 const int IsFunctionT = 1;
5 else
6 const int IsFunctionT = 0;
7 }
8
9 void test()
10 {
11
12 typedef int fp(int);
13
14 assert(IsFunctionT!(fp) == 1);
15 }
还有更简单点的：
void test()
{
typedef int fp(int);
assert( is(fp == function) );
}