从C＋＋到D

从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