CプログラマのためのD言語

熟練したCプログラマは誰でも、 自然とさまざまなイディオムやテクニックを身につけているものです。 新しい言語を学ぼうとすると、時にこれらのイディオムに慣れすぎたせいで、 同じことを別の言語でどう実現するのかわからなくなってしまいます。 そこでここに、C のよく知られたテクニックと、対応するDでのやり方を集めてみました。

C にはオブジェクト指向関連の機能はありませんので、 オブジェクト指向の話は C++ プログラマのための D 言語 に分けて書きました。

C のプリプロセッサについては Cプリプロセッサ vs D で扱っています。

• 型のサイズを取得する
• 型の最大・最小値を取得する
• 組み込みデータ型
• 特殊な浮動小数点数の値
• 浮動小数点数の剰余
• 浮動小数点数の比較でのNaNの扱い
• assert
• 配列要素の初期化
• 配列の要素ごとのループ
• 可変長配列の作成
• 文字列連結
• 整形print
• 関数の前方参照
• 引数を持たない関数
• ラベル付きbreakとcontinue
• goto文
• 構造体タグの名前空間
• 文字列の検索
• 構造体メンバのアラインメント
• 無名構造体・無名共用体
• 構造体の型と変数の宣言
• 構造体メンバのオフセット計算
• 共用体の初期化
• 構造体の初期化
• 配列の初期化
• エスケープされた文字列リテラル
• ASCII文字とワイド文字
• 列挙型と配列の併用
• typedefで新しい型を作る
• 構造体の比較
• 文字列の比較
• 配列のソート
• volatile なメモリアクセス
• 文字列リテラル
• データ構造のなぞり
• 符号なし右シフト
• 動的クロージャ
• 可変個関数引数

型のサイズを取得する

C では

sizeof(int)
sizeof(char *)
sizeof(double)
sizeof(struct Foo)

D では

sizeプロパティを使います：

int.sizeof
(char *).sizeof
double.sizeof
Foo.sizeof

型の最大・最小値を取得する

C では

#include <limits.h>
#include <math.h>

CHAR_MAX
CHAR_MIN
ULONG_MAX
DBL_MIN

D では

char.max
char.min
ulong.max
double.min

bool               =>        bit
char               =>        char
signed char        =>        byte
unsigned char      =>        ubyte
short              =>        short
unsigned short     =>        ushort
wchar_t            =>        wchar
int                =>        int
unsigned           =>        uint
long               =>        int
unsigned long      =>        uint
long long          =>        long
unsigned long long =>        ulong
float              =>        float
double             =>        double
long double        =>        real
_Imaginary long double =>    ireal
_Complex long double   =>    creal

特殊な浮動小数点数の値

C では

#include <fp.h>

NAN
INFINITY

#include <float.h>

DBL_DIG
DBL_EPSILON
DBL_MANT_DIG
DBL_MAX_10_EXP
DBL_MAX_EXP
DBL_MIN_10_EXP
DBL_MIN_EXP

D では

double.nan
double.infinity
double.dig
double.epsilon
double.mant_dig
double.max_10_exp
double.max_exp
double.min_10_exp
double.min_exp

浮動小数点数の剰余

C では

#include <math.h>

float f = fmodf(x,y);
double d = fmod(x,y);
long double r = fmodl(x,y);

D では

float f = x % y;
double d = x % y;
real r = x % y;

浮動小数点数でのNaNの扱い

C では

#include <math.h>

if (isnan(x) || isnan(y))
   result = FALSE;
else
   result = (x < y);

D では

result = (x < y);        // x か y が NaN なら false

assertは守りの堅いコードに必須の要素

C では

Cはassertに直接対応はしていませんが __LINE__ を使って assertマクロが定義されています。__FILE__ や __LINE__ マクロの使い道はこれくらいしか無いように思われます。

#include <assert.h>

assert(e == 0);

D では

assert(e == 0);

配列要素の初期化

C では

#define ARRAY_LENGTH        17
int array[ARRAY_LENGTH];
for (i = 0; i < ARRAY_LENGTH; i++)
   array[i] = value;

D では

int array[17];
array[] = value;

配列の要素ごとのループ

C では

配列の要素数は別に定義されているか、sizeof() を使ったややこしいトリックが必要です。

#define ARRAY_LENGTH        17
int array[ARRAY_LENGTH];
for (i = 0; i < ARRAY_LENGTH; i++)
   func(array[i]);

int array[17];
for (i = 0; i < sizeof(array) / sizeof(array[0]); i++)
   func(array[i]);

D では

int array[17];
for (i = 0; i < array.length; i++)
   func(array[i]);

int array[17];
foreach (int value; array)
   func(value);

可変長配列の作成

C では

#include <stdlib.h>

int array_length;
int *array;
int *newarray;

newarray = (int *)
   realloc(array, (array_length + 1) * sizeof(int));
if (!newarray)
   error("out of memory");
array = newarray;
array[array_length++] = x;

D では

int[] array;

array.length = array.length + 1;
array[array.length - 1] = x;

文字列連結

C では

#include <string.h>

char *s1;
char *s2;
char *s;

// s1 と s2 をつなげて、結果を s に入れる
free(s);
s = (char *)malloc((s1 ? strlen(s1) : 0) +
		  (s2 ? strlen(s2) : 0) + 1);
if (!s)
   error("out of memory");
if (s1)
   strcpy(s, s1);
else
   *s = 0;
if (s2)
   strcpy(s + strlen(s), s2);

// s に "hello" に追加
char hello[] = "hello";
char *news;
size_t lens = s ? strlen(s) : 0;
news = (char *)
   realloc(s, (lens + sizeof(hello) + 1) * sizeof(char));
if (!news)
   error("out of memory");
s = news;
memcpy(s + lens, hello, sizeof(hello));

D では

char[] s1;
char[] s2;
char[] s;

s = s1 ~ s2;
s ~= "hello";

整形print

C では

#include <stdio.h>

printf("Calling all cars %d times!\n", ntimes);

D では

printf("Calling all cars %d times!\n", ntimes);

import std.stdio;

writefln("Calling all cars %s times!", ntimes);

関数の前方参照

C では

void forwardfunc();

void myfunc()
{
   forwardfunc();
}

void forwardfunc()
{
   ...
}

D では

void myfunc()
{
   forwardfunc();
}

void forwardfunc()
{
   ...
}

引数を持たない関数

C では

void function(void);

D では

void function()
{
   ...
}

ラベル付きbreakとcontinue

C では

   for (i = 0; i < 10; i++)
    {
       for (j = 0; j < 10; j++)
       {
	   if (j == 3)
	       goto Louter;
	   if (j == 4)
	       goto L2;
       }
     L2:
       ;
    }
Louter:
    ;

D では

Louter:
   for (i = 0; i < 10; i++)
   {
       for (j = 0; j < 10; j++)
       {
	   if (j == 3)
	       break Louter;
	   if (j == 4)
	       continue Louter;
       }
   }
   // break Louter goes here

Goto Statements

C では

D では

構造体タグ名の名前空間

C では

typedef struct ABC { ... } ABC;

D では

struct ABC { ... }

文字列の検索

C では

#include <string.h>
void dostring(char *s)
{
   enum Strings { Hello, Goodbye, Maybe, Max };
   static char *table[] = { "hello", "goodbye", "maybe" };
   int i;

   for (i = 0; i < Max; i++)
   {
       if (strcmp(s, table[i]) == 0)
	   break;
   }
   switch (i)
   {
       case Hello:   ...
       case Goodbye: ...
       case Maybe:   ...
       default:      ...
   }
}

D では

void dostring(char[] s)
{
   switch (s)
   {
       case "hello":   ...
       case "goodbye": ...
       case "maybe":   ...
       default:        ...
   }
}

構造体メンバのアラインメント

C では

#pragma pack(1)
struct ABC
{
   ...
};
#pragma pack()

D では

Dでは、すべてのDコンパイラ間で共通の、アラインメントを指定する構文が用意されています。 実際に行われるアラインメントは、ABI互換性のために、 各環境でのCコンパイラと合わせて実装されています。 アーキテクチャを越えて同じ特定のメモリレイアウトに合わせるには、 align(1) を使って手動でレイアウトを調整します。

struct ABC
{
   int z;               // z はデフォルトの整列

 align (1) int x;       // x はバイト境界へ
 align (4)
 {
   ...                  // {} 内の宣言はdword境界へ整列
 }
 align (2):             // ここから下ではword境界へ整列

   int y;               // y はword境界へ
}

無名構造体・無名共用体

C では

struct Foo
{
   int i;
   union Bar
   {
      struct Abc { int x; long y; } _abc;
      char *p;
   } _bar;
};

#define x _bar._abc.x
#define y _bar._abc.y
#define p _bar.p

struct Foo f;

f.i;
f.x;
f.y;
f.p;

D では

struct Foo
{
   int i;
   union
   {
      struct { int x; long y; }
      char* p;
   }
}

Foo f;

f.i;
f.x;
f.y;
f.p;

構造体の型と変数の宣言

C では

セミコロンで終わる一つの文で書くか、

struct Foo { int x; int y; } foo;

二行に分けで書きます：

struct Foo { int x; int y; };   // 最後の ; が必要
struct Foo foo;

D では

構造体の定義と変数宣言は同じ文には書けません：

struct Foo { int x; int y; }    // 最後の ; は要らない
Foo foo;

構造体定義の最後に ; がつかないのは、 関数やブロック {} の最後には ; が不要なのに構造体宣言には要る、という混乱する仕様を排除するためです。

構造体メンバのオフセット計算

C では

#include <stddef>
struct Foo { int x; int y; };

off = offsetof(Foo, y);

D では

struct Foo { int x; int y; }

off = Foo.y.offsetof;

共用体の初期化

C では

union U { int a; long b; };
union U x = { 5 };                // メンバ 'a' が 5 に初期化される

D では

union U { int a; long b; }
U x = { a:5 };

構造体の初期化

C では

struct S { int a; int b; };
struct S x = { 5, 3 };

D では

struct S { int a; int b; }
S x = { b:3, a:5 };

Array Initializations

C では

int a[3] = { 3,2,2 };

int b[3][2] = { 2,3, {6,5}, 3,4 };

D では

int[3] a = [ 3, 2, 0 ];
int[3] a = [ 3, 2 ];            // C同様、指定されていない部分は0初期化
int[3] a = [ 2:0, 0:3, 1:2 ];
int[3] a = [ 2:0, 0:3, 2 ];     // 指定がなければ、
				// インデックスは直前+1

enum color { black, red, green }
int[3] c = [ black:3, green:2, red:5 ];

int[2][3] b = [ [2,3], [6,5], [3,4] ];

int[2][3] b = [[2,6,3],[3,5,4]];            // エラー

エスケープされた文字列リテラル

C では

char file[] = "c:\\root\\file.c";

/"[^\\]*(\\.[^\\]*)*"/

C では、これはほとんど笑い話です：

char quoteString[] = "\"[^\\\\]*(\\\\.[^\\\\]*)*\"";

D では

char[] file = `c:\root\file.c`;
char[] quoteString = \"  r"[^\\]*(\\.[^\\]*)*"  \";

char[] hello = "hello world" \n;

ASCII文字とワイド文字

モダンなプログラムでは、国際化のためにwchar文字を簡単に扱える必要があります。

C では

#include <wchar.h>
char foo_ascii[] = "hello";
wchar_t foo_wchar[] = L"hello";

#include <tchar.h>
tchar string[] = TEXT("hello");

D では

char[] foo_ascii = "hello";        // 文字列はASCIIとされる
wchar[] foo_wchar = "hello";       // 文字列はワイド文字とされる

列挙型と配列の併用

C では

enum COLORS { red, blue, green, max };
char *cstring[max] = {"red", "blue", "green" };

D では

enum COLORS { red, blue, green }

char[][COLORS.max + 1] cstring =
[
    COLORS.red   : "red",
    COLORS.blue  : "blue",
    COLORS.green : "green",
];

typedefで新しい型を作る

C では

typedef void *Handle;
void foo(void *);
void bar(Handle);

Handle h;
foo(h);			// みつかりにくいバグ
bar(h);			// ok

struct Handle__ { void *value; }
typedef struct Handle__ *Handle;
void foo(void *);
void bar(Handle);

Handle h;
foo(h);			// 構文エラー
bar(h);			// ok

#define HANDLE_INIT ((Handle)-1)

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

struct Handle__ HANDLE_INIT;

void init_handle()	// スタートアップ時にこの関数を呼ぶこと
{
    HANDLE_INIT.value = (void *)-1;
}

Handle h = HANDLE_INIT;
h = func();
if (memcmp(&h,&HANDLE_INIT,sizeof(Handle)) != 0)
    ...

D では

typedef void* Handle;
void foo(void*);
void bar(Handle);

Handle h;
foo(h);
bar(h);

typedef void* Handle = cast(void*)(-1);
Handle h;
h = func();
if (h != Handle.init)
    ...

構造体の比較

C では

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

#include <string.h>

struct A x, y;
...
if (memcmp(&x, &y, sizeof(struct A)) == 0)
    ...

しかも、memcmp() による operator==() の実装には困ったバグが潜んでいます。 アラインメントのせいで、構造体のメンバの間には '穴' があるかもしれません。 C はこの穴にどんな値が入るかは保証してくれませんので、 例え全てのメンバの値が等しくても、インスタンスによって'穴'の値が違うせいで "異なっている"と判定されてしまうかもしれません。

D では

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

文字列の比較

C では

char string[] = "hello";

if (strcmp(string, "betty") == 0)	// 文字列は一致するだろうか？
    ...

D では

char[] string = "hello";

if (string == "betty")
    ...

D は、文字列の比較演算子もサポートしています：

char[] string = "hello";

if (string < "betty")
    ...

配列のソート

C では

int compare(const void *p1, const void *p2)
{
    type *t1 = (type *)p1;
    type *t2 = (type *)p2;

    return *t1 - *t2;
}

type array[10];
...
qsort(array, sizeof(array)/sizeof(array[0]),
	sizeof(array[0]), compare);

D では

type[] array;
...
array.sort;      // 配列を in-place でソート

volatile なメモリアクセス

C では

volatile int *p = address;

i = *p;

D では

int* p = address;

volatile { i = *p; }

文字列リテラル

C では

"This text spans\n\
multiple\n\
lines\n"

D では

"This text spans
multiple
lines
"

データ構造のなぞり

C では

このために、木を再帰的にたどる補助関数 membersearchx が要ります。 補助関数には木自体には含まれない、コンテキストの情報が必要です。 そこで、 struct Paramblock を定義してパラメータとしてそのポインタを渡します。

struct Symbol
{
   char *id;
   struct Symbol *left;
   struct Symbol *right;
};

struct Paramblock
{
   char *id;
   struct Symbol *sm;
};

static void membersearchx(struct Paramblock *p, struct Symbol *s)
{
   while (s)
   {
      if (strcmp(p->id,s->id) == 0)
      {
         if (p->sm)
            error("ambiguous member %s\n",p->id);
         p->sm = s;
      }

      if (s->left)
         membersearchx(p,s->left);
      s = s->right;
   }
}

struct Symbol *symbol_membersearch(Symbol *table[], int tablemax, char *id)
{
   struct Paramblock pb;
   int i;

   pb.id = id;
   pb.sm = NULL;
   for (i = 0; i < tablemax; i++)
   {
      membersearchx(pb, table[i]);
   }
   return pb.sm;
}

D では

パフォーマンス面でも差はありません。

class Symbol
{   char[] id;
    Symbol left;
    Symbol right;
}

Symbol symbol_membersearch(Symbol[] table, char[] id)
{   Symbol sm;

    void membersearchx(Symbol s)
    {
	while (s)
	{
	    if (id == s.id)
	    {
		if (sm)
		    error("ambiguous member %s\n", id);
		sm = s;
	    }

	    if (s.left)
		membersearchx(s.left);
	    s = s.right;
	}
    }

    for (int i = 0; i < table.length; i++)
    {
	membersearchx(table[i]);
    }
    return sm;
}

符号なし右シフト

C では

int i, j;
...
j = (unsigned)i >> 3;

myint i, j;
...
j = (unsigned)i >> 3;

D では

myint i, j;
...
j = i >>> 3;

動的クロージャ

C では

汎用のコンテキスト用ポインタも必要で、 ここでは void *p としてあります。この例はintの配列を使った簡単な例で、 コンテナのユーザがこれらのintの最大値を計算しようとしています。

void apply(void *p, int *array, int dim, void (*fp)(void *, int))
{
    for (int i = 0; i < dim; i++)
	fp(p, array[i]);
}

struct Collection
{
    int array[10];
};

void comp_max(void *p, int i)
{
    int *pmax = (int *)p;

    if (i > *pmax)
	*pmax = i;
}

void func(struct Collection *c)
{
    int max = INT_MIN;

    apply(&max, c->array, sizeof(c->array)/sizeof(c->array[0]), comp_max);
}

この方法で確かに機能を実現はできますが、柔軟性があるとは言い難いものになっています。

D では

class Collection
{
    int[10] array;

    void apply(void delegate(int) fp)
    {
	for (int i = 0; i < array.length; i++)
	    fp(array[i]);
    }
}

void func(Collection c)
{
    int max = int.min;

    void comp_max(int i)
    {
	if (i > max)
	    max = i;
    }

    c.apply(&amp;comp_max);
}

void func(Collection c)
{
    int max = int.min;

    c.apply(delegate(int i) { if (i > max) max = i; } );
}

可変個関数引数

C では

#include <stdio.h>
#include <stdarg.h>

int sum(int dim, ...)
{   int i;
    int s = 0;
    va_list ap;

    va_start(ap, dim);
    for (i = 0; i < dim; i++)
	s += va_arg(ap, int);
    va_end(ap);
    return s;
}

int main()
{
    int i;

    i = sum(3, 8,7,6);
    printf("sum = %d\n", i);

    return 0;
}

D では

import std.stdio;

int sum(int[] values ...)
{
    int s = 0;

    foreach (int x; values)
	s += x;
    return s;
}

int main()
{
    int i;

    i = sum(8,7,6);
    writefln("sum = %d", i);

    return 0;
}