C++プログラマーのためのD言語プログラミング

経験豊富なC++プログラマーは、自然に使えるようになるイディオムやテクニックを蓄積している。 新しい言語を学習する際、それらの イディオムが快適すぎて、新しい言語で同等の処理を行う方法がわからないことがある。 そこで、ここでは一般的なC++テクニックと、それに対応する Dでの処理方法を紹介する。

コンストラクタの定義

C++の方法

class Foo
{
    Foo(int x);
};

Dの方法

class Foo
{
    this(int x) { }
}

基本クラスの初期化

C++の方法

class A { A() {... } };
class B : A
{
    B(int x)
        : A()   // 基本コンストラクタを呼び出す
    {
        ...
    }
};

Dの方法

class A { this() { ... } }
class B : A
{
    this(int x)
    {
        ...
        super();    // 基本コンストラクタを呼び出す
        ...
    }
}

class A
{
    int a;
    int b;
    this() { a = 7; b = foo(); }
    this(int x)
    {
        this();
        a = x;
    }
}

class A
{
    int a = 7;
    int b;
    this() { b = foo(); }
    this(int x)
    {
        this();
        a = x;
    }
}

構造体を比較する

C++の方法

struct A x, y;
...
x = y;

#include <string.h>

struct A x, y;

inline bool operator==(const A& x, const A& y)
{
    return (memcmp(&x, &y, sizeof(struct A)) == 0);
}
...
if (x == y)
    ...

演算子オーバーロードは比較が必要なすべての構造体に対して行う必要があることに 注意し、そのオーバーロード演算子の実装は、型チェックに関する言語のサポートを一切受けない。 C++の方法には、さらに問題がある。 (x == y) を調べただけでは、実際に何が起こっているのかわからない。

memcmp() での operator==() の実装には厄介なバグが潜んでいる。 構造体のレイアウトは、アラインメントの関係で「穴」が生じる可能性がある。 C++ はこれらの穴に値が割り当てられることを保証しないため、 異なる2つの構造体インスタンスが各メンバに同じ値を持つことがあり得るが、 穴に異なるガベージが含まれるため、比較結果は異なる。

この問題に対処するために、operator==() を実装してメンバごとに比較を行うことができる。 しかし残念ながら、これは信頼性に欠ける。なぜなら、(1) メンバが構造体定義に追加された場合、 operator==() に追加し忘れる可能性があること、および、(2) 浮動小数点の nan 値は、ビットパターンが一致していても比較結果が異なる

Dの方法

A x, y;
...
if (x == y)
    ...

新しい型定義型を作成する

C++のやり方

#define HANDLE_INIT     ((Handle)(-1))
typedef void *Handle;
void foo(void *);
void bar(Handle);

Handle h = HANDLE_INIT;
foo(h);         // コーディングバグが見つからない
bar(h);         // OK

#define HANDLE_INIT     ((void *)(-1))
struct Handle
{
    void *ptr;

    // デフォルトの初期化子
    Handle() { ptr = HANDLE_INIT; }

    Handle(int i) { ptr = (void *)i; }

    // 基本型への変換
    operator void*() { return ptr; }
};
void bar(Handle);

Handle h;
bar(h);
h = func();
if (h != HANDLE_INIT)
    ...

Dの方法

alias Handle = Typedef!(void*, cast(void*)-1);
void bar(Handle);

Handle h;
bar(h);
h = func();
if (h != Handle.init)
    ...

Friends

C++の方法

class A
{
  private:
    int a;

  public:
    int foo(B *j);
    friend class B;
    friend int abc(A *);
};

class B
{
  private:
    int b;

  public:
    int bar(A *j);
    friend class A;
};

int A::foo(B *j) { return j->b; }
int B::bar(A *j) { return j->a; }

int abc(A *p) { return p->a; }

Dの方法

module X;

class A
{
  private:
    static int a;

  public:
    int foo(B j) { return j.b; }
}

class B
{
  private:
    static int b;

  public:
    int bar(A j) { return j.a; }
}

int abc(A p) { return p.a; }

演算子オーバーロード

C++の方法

struct A
{
    int operator <  (int i);
    int operator <= (int i);
    int operator >  (int i);
    int operator >= (int i);
};

int operator <  (int i, A &a) { return a >  i; }
int operator <= (int i, A &a) { return a >= i; }
int operator >  (int i, A &a) { return a <  i; }
int operator >= (int i, A &a) { return a <= i; }

Dの方法

struct A
{
    int opCmp(int i);
}

コンパイラは、 <、<=、>、および>= 演算子をすべて自動的にcmp 関数の観点で解釈し、 左オペランドがオブジェクト参照ではない場合も処理する。

同様の賢明なルールは、他の演算子オーバーロードにも適用され、 Dでの演算子オーバーロードの使用をはるかに面倒でなく、エラーを起こしにくいものにしている。同じ効果を得るために書く必要のあるコードははるかに少ない。

名前空間を使用する宣言

C++の方法

namespace foo
{
    int x;
}
using foo::x;

Dの方法

/** foo.dモジュール **/
module foo;
int x;

/** 別のモジュール **/
import foo;
alias x = foo.x;

RAII(リソース取得は初期化である)

C++の方法

class File
{
    Handle *h;

    ~File()
    {
        h->release();
    }
};

Dの方法

リソース解放の問題の大部分は、単純に メモリの追跡と解放を行うことである。Dでは、これはガベージコレクタによって自動的に処理される。 2番目に良く使用されるリソースはセマフォとロックであり、 これらはDのsynchronized宣言と文によって自動的に処理される。

残りのRAIIの問題は、structによって処理される。struct は、スコープ外に出るとデストラクタが実行される。

struct File
{
    Handle h;

    ~this()
    {
        h.release();
    }
}

void test()
{
    if (...)
    {
        auto f = File();
        ...
    } // f.~this()は、スローされた例外によってスコープが終了した場合でも、
      // 終了ブレースで実行される。
}

class通常、ガベージコレクタによって管理されるが、これは RAIIには適していない。classによる決定論的な破棄が必要な場合は、 を使用できる std.typecons.scoped(これも ガベージコレクタが管理するヒープではなく、スタック上にclass を割り当てる)。

ScopeGuardStatementも参照のこと。 現在のスコープを離れる際に任意の文を実行できる、より一般的な メカニズムである。

プロパティ

C++の方法

class Abc
{
  public:
    void setProperty(int newproperty) { property = newproperty; }
    int getProperty() { return property; }

  private:
    int property;
};

Abc a;
a.setProperty(3);
int x = a.getProperty();

Dの方法

class Abc
{
    // 設定
    @property void property(int newproperty) { myprop = newproperty; }

    // 取得
    @property int property() { return myprop; }

  private:
    int myprop;
}

Abc a = new Abc;
a.property = 3;
int x = a.property;

再帰的テンプレート

C++の方法

template<int n> class factorial
{
  public:
    enum { result = n * factorial<n - 1>::result };
};

template<> class factorial<1>
{
  public:
    enum { result = 1 };
};

void test()
{
    printf("%d\n", factorial<4>::result); // 24を表示する
}

Dの方法

template factorial(int n)
{
    enum factorial = n * .factorial!(n-1);
}

template factorial(int n : 1)
{
    enum factorial = 1;
}

void test()
{
    writeln(factorial!(4));  // 24を表示する
}

enum factorial(int n) = n * .factorial!(n-1);

enum factorial(int n : 1) = 1;

メタテンプレート

C++の方法

この例は、 カルロ・ペスチョ博士が 「テンプレート・メタプログラミング:この新しいテクニックでパラメータ化された整数をポータブルにする」で書いたものを簡略化し、一部修正したものである。

C++では、テンプレートパラメータに基づく式の結果に基づいて条件付きコンパイルを行う方法はないため、 すべての制御フローは、テンプレート引数とさまざまな明示的なテンプレート特殊化のパターンマッチングに従う。 さらに悪いことに、「以下」のような関係に基づいてテンプレート特殊化を行う方法もないため、 この例では、テンプレートが再帰的に展開され、 特殊化が一致するまで、テンプレート値の引数を毎回1ずつ増やしながら、 テンプレートを再帰的に展開する巧妙なテクニックが使用されている。 一致しない場合は、役に立たない再帰コンパイラのスタックオーバーフローや内部エラー、あるいはせいぜい奇妙な構文エラーが発生する。

#include <limits.h>

template< int nbits > struct Integer
{
    typedef Integer< nbits + 1 > :: int_type int_type ;
};

struct Integer< 8 >
{
    typedef signed char int_type ;
};

struct Integer< 16 >
{
    typedef short int_type ;
};

struct Integer< 32 >
{
    typedef long int_type ;
};

struct Integer< 64 >
{
    typedef long long int_type ;
};

// 必要なサイズがサポートされていない場合、
// メタプログラムは内部エラーが通知されるか、
// INT_MAXに達するまでカウンタを増やす。INT_MAXの特殊化では
// int_typeを定義しないため、常
// にコンパイルエラーが発生する。
struct Integer< INT_MAX >
{
};

// 構文糖
#define Integer( nbits ) Integer< nbits > :: int_type

#include <stdio.h>

int main()
{
    Integer( 8 ) i ;
    Integer( 16 ) j ;
    Integer( 29 ) k ;
    Integer( 64 ) l ;
    printf("%d %d %d %d\n",
        sizeof(i), sizeof(j), sizeof(k), sizeof(l));
    return 0 ;
}

C++ Boost による方法

#include <boost/mpl/if.hpp>
#include <boost/mpl/assert.hpp>

template <int nbits> struct Integer
    : mpl::if_c<(nbits <= 8), signed char
    , mpl::if_c<(nbits <= 16), short
    , mpl::if_c<(nbits <= 32), long
    , long long>::type >::type >
{
    BOOST_MPL_ASSERT_RELATION(nbits, <=, 64);
}

#include <stdio.h>

int main()
{
    Integer< 8 > i ;
    Integer< 16 > j ;
    Integer< 29 > k ;
    Integer< 64 > l ;
    printf("%d %d %d %d\n", sizeof(i), sizeof(j), sizeof(k), sizeof(l));
    return 0 ;
}

Dの方法

import std.stdio;

template Integer(int nbits)
{
    static if (nbits <= 8)
        alias Integer = byte;
    else static if (nbits <= 16)
        alias Integer = short;
    else static if (nbits <= 32)
        alias Integer = int;
    else static if (nbits <= 64)
        alias Integer = long;
    else
        static assert(0);
}

int main()
{
    Integer!(8) i ;
    Integer!(16) j ;
    Integer!(29) k ;
    Integer!(64) l ;
    writefln("%d %d %d %d", i.sizeof, j.sizeof, k.sizeof, l.sizeof);
    return 0;
}

型トレイト

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の方法

template IsFunctionT(T)
{
    static if ( is(T[]) )
        const int IsFunctionT = 0;
    else
        const int IsFunctionT = 1;
}

void test()
{
    alias int fp(int);

    assert(IsFunctionT!(fp) == 1);
}

void test()
{
    alias int fp(int);

    assert( is(fp == function) );
}

インターフェース

C++のインターフェイス

class Interface {
  public:
    virtual int method() = 0;
};

class FirstVariant : public Interface {
  public:
    int method() {
      ...
    }
};

class SecondVariant : public Interface {
  public:
    int method() {
      ...
    }
};

FirstVariant FirstVariant;
SecondVariant SecondVariant;

FirstVariant.method();
SecondVariant.method();

D言語におけるインターフェース

interface Interface {
  int method();
}

class FirstVariant : Interface {
  int method() {
    ...
  }
}

class SecondVariant : Interface {
  int method() {
    ...
  }
}

FirstVariant FirstVariant = new FirstVariant();
SecondVariant SecondVariant = new SecondVariant();

FirstVariant.method();
SecondVariant.method();

D言語における参照

module test;

void main()
{
    struct Data
    {
        int id;
    }

    import std.container.array : Array;
    Array!Data gallery;

    Data d1;
    gallery.insertBack(d1);

    auto d2 = gallery[0];
    d2.id = 1;
    assert(d2.id == gallery[0].id, "neither ref nor pointer");
}

    auto d2 = &gallery[0];