株式会社エス・スリー・フォー » article

C++の新しいキャスト

cpptechdoc — Mon, 02 Apr 2007 05:59:48 +0000

従来のキャストの問題点

異なる型への変換において、C/C++ではキャストが用いられます。

// intからlongへのキャスト
int ival;
int lval = (long)ival;

ご存知のとおり、キャストは非常に危険です。本来ならば型の不一致によるコンパイルエラーをねじ伏せるのですから。

キャストの使われ方(意味)は、大きく3種(型変換/型変更/const外し)に分類されます。

型変換

// int から double へ
int ival;
double dval = (double)ival;

型変更

// long から int* へ
long lval;
int* iptr = (int*)lval;

const外し

// const int* から int* へ
const int* ciptr;
int* iptr = (int*)ciptr;

上記のどの目的でキャストしても、構文としてはどれも同じ

(型)式

です。つまりコードからは”何が目的でキャストしたのかはっきりしない“のですね。

4種類の新しいキャスト

キャストは使わずに済ませられるならそれに越したとはないのですが、どうしても使わざるを得ないシチュエーションは少なからず存在します。
ならばせめて少しでも安全にキャストするために新たに定められたキャスト構文が、以下に挙げるstatic_cast / reinterpret_cast / const_cast / dynamic_cast です。

static_cast

static_cast(expr)

static_castはexprの型からtypeへの暗黙の型変換、あるいはtypeからexprへの暗黙の型変換が存在する場合にだけキャストします。キャスト不可能であればコンパイルエラーとなります。

// int から long へ
int ival;
long lval = static_cast(ival);

reinterpret_cast

reinterpret_cast(expr)

reinterpret_castはtype(expr)が許されるなら、exprをtypeに単にキャストします。

// long から int* へ
long lval;
int* iptr = reinterpret_cast(lval);

reinterpret_castは単なる型変更であり、たとえ派生関係があったとしてもポインタのアドレス自体はキャスト前と変わりません。
その意味でreinterpret_castは非常に危険なキャストといえるでしょう。

const_cast

const_cast<type>(expr)

const_castはconstおよびvolatile修飾子を無効にするだけのキャストを行ないます。そのほかのときはコンパイルエラーとします。

// const int* から int* へ
const int* ciptr;
int* iptr = const_cast(ciptr);

dynamic_cast

dynamic_cast(expr)

dynamic_castは基底クラスへのポインタ(or 参照)から派生クラスへのポインタ(or 参照)への型保証キャストを行ないます。

上記3種のキャストはコンパイル時にキャストしますが、dynamic_castは実行時に型の検査が行なわれ、変換不可能であれば0を返します。

class Base { ... };
class Derived : public Base { ... };

Base base;
Derived derived;

Derived* pd1 = dynamic_cast(&base); // 失敗 pd1 == 0
Derived* pd2 = dynamic_cast(&derived);

参照のキャストに失敗すると、std::bad_cast例外がthrowされます。

try {
  Derived& rd1 = dynamic_cast(base);
} catch ( const std::bad_cast& e ) {
  std::cout << e.what() << std::endl;
};

dynamic_castにより、従来のキャストでは不可能であったクロス・キャスト、そして抽象基底クラスからのダウン・キャストが可能になりました。

クロス・キャスト

/*
 * Shape と Drawable は派生関係にない
 */
class Shape {
 ...
};

class Drawable {
public:
  virtual void draw() =0;
};

/*
 * Circle は Drawable にキャスト可能
 */
class Circle : public Shape, public Drawable {
public:
  virtual void draw();
};

Shape* shape = new Circle;
/* 従来のキャスト (Drawable*)shape では、
 * 場合によっては暴走する */
Drawable* drawable = dynamic_cast(shape);
if ( drawable )
  drawable->draw();

抽象基底クラスからのダウン・キャスト

class Machine {
  ...
};

class TV : virtual public Machine {
public:
  void tune(int channel);
};

class VTR : virtual public Machine {
public:
  void record();
};

class TeleVideo : public TV, public VTR {
  ...
};

Machine* machine = new TeleVideo;
/* 従来のキャスト (TeleVideo*)machine はコンパイルエラー */
TeleVideo* televideo = dynamic_cast(machine);
if ( televideo ) {
  televideo->tune(8);
  televideo->record();
}

※注意

dynamic_castが適用できるのはポリモルフィック・クラス、すなわち少なくとも一つのメンバ関数が仮想関数でなくてはなりません。

struct non_polymorpic { ... }; // 仮想関数が存在しない
struct something : non_polumorphic { ... };
non_polymorphic* p;
something* q = dynamic_cast(p); // error!

新しいキャストは従来のキャストよりはるかに安全です。
また､grepなどで”_cast”をキーにすればキャストした個所を簡単に検索できるという副次的な効果もあります。

sizeofの不思議

cpptechdoc — Mon, 02 Apr 2007 05:59:48 +0000

はじめに

Cではsizeofによって構造体がメモリ上で占める大きさ(バイト数)を知ることができます。

struct s{
  int x;
  int y;
};
...
cout << sizeof(s) << endl;

僕の愛用する処理系、Visual C++ 6.0では 8が得られました。intひとつにつき4byteを消費するからでしょう。

それではC++でのclassの大きさはどうでしょう。内包するメンバ変数それぞれの占めるバイト数の総和になるのでしょうか。

class c {
  int x;
  int y;
};
...
cout << sizeof(c) << endl;

答は…やはり 8 です。でもね、C++ではいつもこうなるとは限らないのですよ。

「C++はCよりデカい」と言われることがあります。その理由のひとつがここに明らかになります。

仮想関数

上記class cにメンバ関数を追加します。

class c {
  int x;
  int y;
public:
  int sum();
};
...
cout << sizeof(c) << endl;

結果は 8 でした。メンバ関数を追加してもサイズに変化はないようです。

ところが、仮想関数を追加すると…

class c {
  int x;
  int y;
public:
  virtual int sum();
};
...
cout << sizeof(c) << endl;

結果は12。4バイト増加しています。まるでメンバ関数へのポインタがクラス内にこっそり追加されたかのようです。
ならば仮想関数が2つあったら8バイト増えるのかな…

class c {
  int x;
  int y;
public:
  virtual int sum();
  virtual int sub();
};
...
cout << sizeof(c) << endl;

依然として 12 のままです。実体を伴わない純粋仮想関数を追加したら…

class c {
  int x;
  int y;
public:
  virtual int sum() =0;
};
...
cout << sizeof(c) << endl;

…ふむ、純粋仮想関数を追加してもクラスの大きさは 12 ですね。

これらのことから、クラスに仮想関数がひとつ以上あるとき、クラスの大きさは 4 バイト増加すると思われます。

何故でしょう。その理由は仮想関数が実行されるときのからくりにあります。

仮想関数を含むクラスを宣言すると、そのクラスの中メンバ変数'vptr'がひとつ、こっそり追加されます。これは"仮想関数へのポインタ配列'vtbl'へのポインタ"です。
vtblはクラス内にある仮想関数のポインタを配列内に納めたもので、仮想関数を含むクラス毎にひとつ作られます。仮想関数がコールされるとき、vptrの指す配列vtblの特定の位置から仮想関数へのポインタを取り出し、そこをコールします。

このようなからくりのために、仮想関数を含むクラスは、仮想関数のないクラスより少し大きいのです。

継承

継承したときのクラスの大きさはどうでしょうか。

class c0 {
  int x;
  int y;
};

class c1 : public c0 {
  int a;
  int b;
};
...
cout << sizeof(c0) << endl;
cout << sizeof(c1) << endl;

結果はそれぞれ 8,16 でした、予想通りの結果です。

仮想関数を含むとどうなるでしょう。

class c0 {
public:
  int x;
  int y;
  virtual int sum();
};

class c1 : public c0 {
public:
  int a;
  int b;
  virtual int diff();
};
...
cout << sizeof(c0) << endl;
cout << sizeof(c1) << endl;

sizeof(c0)が 12だから、c1はそれにint2個分(8byte)と'vptr'(4byte)を加えて 24 …ではなくて 20 となりました。仮想関数テーブルポインタ'vptr'はクラス内にひとつあればいいからです。

cout << offsetof(c1,x) << endl;
cout << offsetof(c1,y) << endl;
cout << offsetof(c1,a) << endl;
cout << offsetof(c1,b) << endl;

の結果はそれぞれ、4, 8, 12, 16 となりました、このことから、class c1のメモリ上でのレイアウトは、

offset	member
+0	c1::vptr
+4	c0::x
+8	c0::y
+12	c1::a
+16	c1::b

となっていると考えられます。

多重継承

多重継承の場合、ちょっとばかしややこしくなります。

class c0 {
public:
  int x0;
  int y0;
  virtual void f0() {}
};

class c1 {
public:
  int x1;
  int y1;
  virtual void f1() {}
};

class c2 : public c0, public c1 {
public:
  int x2;
  int y2;
  virtual void f2() {}
};
...
cout << "c0  :        " << sizeof(c0)  << endl;
cout << "c1  :        " << sizeof(c1)  << endl;
cout << "c2  : c0, c1 " << sizeof(c2)  << endl;

'仮想関数ポインタテーブル(vptr)はクラスにひとつ'であるならば、sizeof(c2)は、10,c1,c2それぞれのメンバ変数領域の総和(8×3=24byte)にvptr(4byte)を加えた28byteとなりそうです。

ところが結果は予想に反して 32となりました。vptrが2つ含まれているようです。

cout << offsetof(c2, x0) << endl;
cout << offsetof(c2, y0) << endl;
cout << offsetof(c2, x1) << endl;
cout << offsetof(c2, y1) << endl;
cout << offsetof(c2, x2) << endl;
cout << offsetof(c2, y2) << endl;

の結果: 4, 8, 16, 20, 24, 28 から察するに、c2のメモリ・レイアウトは:

offset	member
+0	c2::vptr
+4	c0::x0
+8	c0::y0
+12	c1::vptr
+16	c1::x1
+20	c1::y1
+24	c1::x2
+28	c1::y2

であろうと考えられます。

仮想継承

さらに仮想継承を考えると、話はさらにややこしくなります。

class c0 {
public:
  int x0;
  int y0;
  virtual void f0() {}
};

class c1 : virtual public c0 {
public:
  int x1;
  int y1;
  virtual void f1() {}
};

class c2 : virtual public c0 {
public:
  int x2;
  int y2;
  virtual void f2() {}
};

class c3 : public c1, public c2 {
public:
  int x3;
  int y3;
  virtual void f3() {}
};
...
cout << "c0  :        " << sizeof(c0)  << endl;
cout << "c1  : c0     " << sizeof(c1)  << endl;
cout << "c2  : c0     " << sizeof(c2)  << endl;
cout << "c3  : c1, c2 " << sizeof(c3)  << endl;

sizeof(c3)は 52 となりました。なんとも不思議な結果です。上記の各クラスから仮想関数を抜き取ってみましょう。

class c0 {
public:
  int x0;
  int y0;
};

class c1 : virtual public c0 {
public:
  int x1;
  int y1;
};

class c2 : virtual public c0 {
public:
  int x2;
  int y2;
};

class c3 : public c1, public c2 {
public:
  int x3;
  int y3;
};
...
cout << "c0  :        " << sizeof(c0)  << endl;
cout << "c1  : c0     " << sizeof(c1)  << endl;
cout << "c2  : c0     " << sizeof(c2)  << endl;
cout << "c3  : c1, c2 " << sizeof(c3)  << endl;

このとき、sizeof(c3)は 40となりました。仮想継承したベースクラスc0の各メンバは、c3内にはひとつしかないはずなので、予想されるサイズは (8×4=)32
であるはずなのに、8byte余計な領域を必要としています。仮想関数を元に戻し、

cout << offsetof(c3, x1) << endl;
cout << offsetof(c3, y1) << endl;
cout << offsetof(c3, x2) << endl;
cout << offsetof(c3, y2) << endl;
cout << offsetof(c3, x3) << endl;
cout << offsetof(c3, y3) << endl;

を実行すると、それぞれ 8, 12, 24, 28, 32, 36
となりました。この結果から得られるメモリ・レイアウトは:

offset	member
+0	???
+4	???
+8	c1::x1
+12	c1::y1
+16	???
+20	???
+24	c2::x2
+28	c2::y2
+32	c3::x3
+36	c3::y3
+40	???
+44	???
+48	???

'???'の領域のうち、少なくとも2つはc0::x0とc0::y0でしょう。

「C++はCよりデカい」か?

結論から言うと、仮想関数、多重継承、仮想継承などなどを駆使したC++コードは確かにデカくなることがわかりました。最後の例など、Cでなら32byteで済むところが、20byteも余計にメモリを消費します。インスタンスひとつにつき20byteのメモリを余計に消費するのですからアプリケーション全体では無視できないでしょうね。

しかし、だからといってC++コードから仮想関数を排除するのは決して得策とは思えません。仮想関数と同じふるまいを仮想関数なしで実現するには、オブジェクトの本来の型を識別するためのIDをメンバとして用意しなければなりませんし、関数呼び出しのたびに、IDによる処理の振り分けを行なうことになります。結局仮想関数を用いた場合と同等のサイズになることが予想されるうえ、コードのメンテナンス性が著しく低下するでしょう。

※注意:
これはMicrosoft Visual C++ v6.0での実験結果です。
これ以外のOSや処理系では異なる結果が得られることでしょう。

おまけ : やりがちな誤り

仮想関数のお話ついでに、うっかりやってしまいそうな誤りをひとつ紹介しておきます。あなたはいくつかのクラスを設計/実装することになり、それぞれのコンストラクタ/デストラクタが確実に行われているか、画面に表示して確かめたくなりました。そこであなたはこんなコードを書きました。

class base {
public:
  base();
  virtual ‾base();
  virtual void on_ctor();
  virtual void on_dtor();
};

base::base() {
  on_ctor();
}

base::‾base() {
  on_dtor();
}

void base::on_ctor() {
  cout << "base::ctor¥n";
}

void base::on_dtor() {
  cout << "base::dtor¥n";
}

class baseはそのコンストラクタ/デストラクタの中からそれぞれ仮想関数on_ctor()/on_dtor()を呼んでいます。ですからbaseの派生クラス側でon_ctor()/on_dtor()を再定義すればいいはずです。

class c0 : public base {
public:
  virtual void on_ctor();
  virtual void on_dtor();
};

void c0::on_ctor() {
  cout << "c0::ctor¥n";
}

void c0::on_dtor() {
  cout << "c0::dtor¥n";
}

class c1 : public base {
public:
  virtual void on_ctor();
  virtual void on_dtor();
};

void c1::on_ctor() {
  cout << "c1::ctor¥n";
}

void c1::on_dtor() {
  cout << "c1::dtor¥n";
}

int main() {
  c0 x;
  c1 y;
  return 0;
}

さて、結果はどうなったでしょう…

base::ctor
base::ctor
base::dtor
base::dtor

惨澹たる結果となりました。

そう、C++ではコンストラクタ/デストラクタの中から仮想関数を呼んでも、導出クラスで再定義された関数には飛んでこないんです。

この例のように、コンストラクタ/デストラクタから直接仮想関数を呼んでいるのであればそれに気づくのにそう時間はかからないのですが、コンストラクタ/デストラクタが呼んでいる関数の中、あるいはさらにそこから呼ばれている関数…
コンストラクタ/デストラクタが終了するまでに直接的あるいは間接的に呼ばれている一連の関数の中に仮想関数が含まれていたとき、そのふるまいは意図しているものとは異なることになるのです。

コンストラクタ/デストラクタ内から仮想関数を呼び出すことはできませんから、仕方なしにコンストラクト/デストラクトと初期化/後始末を分離しなければなりません。

// ----- これならちゃんと動く,,, -----
class base {
public:
  base() {}
  virtual ‾base() {}
  void    start();
  void    stop();
  virtual void on_ctor();
  virtual void on_dtor();
};

void base::start() {
  on_ctor();
}

void base::stop() {
  on_dtor();
}

void base::on_ctor() {
  cout << "base::ctor¥n";
}

void base::on_dtor() {
  cout << "base::dtor¥n";
}

/*
 * c0, c1 はそのまま...
 */

int main() {
  c0 x; x.start();
  c1 y; y.start();
  y.stop();
  x.stop();
  return 0;
}

これがJavaだと思った通りに動いてくれます。ま、Javaにはデストラクタがありませんけど…

// ----- Trial.java -----
class base {
  base() {
    on_ctor();
  }
  void on_ctor() {
    System.out.println("base::ctor");
  }
  protected void finalize() {
    System.out.println("base::dtor");
  }
}

class c0 extends base {
  void on_ctor() {
    System.out.println("c0::ctor");
  }
  protected void finalize() {
    System.out.println("c0::dtor");
  }
}

class c1 extends base {
  void on_ctor() {
    System.out.println("c1::ctor");
  }
  protected void finalize() {
    System.out.println("c1::dtor");
  }
}

public class Trial {
  public static void main(String[] arg) throws Exception {
    c0 x = new c0();
    c1 y = new c1();
  }
}

実行結果:

c0::ctor
c1::ctor

…ほらね。

抽象データ型と Java/C++ そして COM/CORBA

cpptechdoc — Mon, 02 Apr 2007 05:59:48 +0000

抽象データ型とは…

抽象データ型
継承
多態

をオブジェクト指向の三本柱などと称しています。その中でも抽象データ型(あるいはデータの抽象化)はオブジェクト指向の最も基本的で重要な概念ではないかと考えます。

"データを抽象化する"とは、データをそれに対して適用できる操作の集合で定義することです。

簡単な例として"カウンタ"を考えてみましょう。カウンタには3つの操作:

+1する (increment)
-1する (decrement)
現在値を取得する

を提供させることにします。

さて、このカウンタをCで実現するとどうなるでしょうか…

typedef struct {
  long value_;
} Counter;

Counter* counter_create();
void     counter_incr(Counter*);
void     counter_decr(Counter*);
long     counter_value(const Counter*);
void     counter_release(Counter*);

/* ---- ここから実装部。Counterの利用者には見せない ---- */

Counter* counter_create() {
  Counter* c = (Counter*)malloc(sizeof(Counter));
  c->value_ = 0;
  return c;
}

void     counter_incr(Counter* c) { ++c->value_; }

void     counter_decr(Counter* c) { --c->value_; }

long     counter_value(const Counter* c) { return c->value_; }

void     counter_release(Counter* c) { free(c); }

…こんな感じになりますか。C++の入門書の中には、

データ(構造体) + アルゴリズム(関数) = オブジェクト(クラス)

と説明されたものもあります。つまり、構造体に、それに適用される操作を付け加えたものがクラスだ、というのです。

class Counter {
private:
  long value_;
public:
  Counter();
  ~Counter();
  void incr();
  void decr();
  long value() const;
};

/* --- ここから実装部。Counterの利用者には見せない --- */

Counte::Counter() : value_(0) {}

Counte::~Counter()  {}

void Counter::incr() { ++value_; }

void Counter::decr() { --value_; }

long Counter::value() const { return value_; }

Counterのメンバ変数value_は、利用者に勝手にアクセスさせないようprivate部に置きました。

カウンタの利用者にしてみればprivateメンバに何が定義されているかなんて(どうせアクセスできないのだから)知る必要もありません。+1できて、-1できて、値を取得できるということだけで十分です。

カウンタの実装者にしても同様です。+1する、-1する、値を返す、の3つの機能をきちんと実装できるのなら、privateメンバはその実現のためになら何を定義しようがかまわない。メソッドが呼ばれるたびに電話回線を通してはるか遠くにあるデータベースを更新・参照したっていいでしょうよ。

結局カウンタについて利用者と実装者との間できめておかなければならないのは、カウンタに対する操作だけなんです。

"Xに対して何ができるか"で定義したX、それが抽象データ型なんですね。

Javaにおける抽象データ型

Javaは、抽象データ型を直接サポートするキーワードinterfaceを持っています。

public interface Counter {
  void incr();
  void decr();
  int  value();
}

interfaceはclassではありません。実体が存在しません。Counterの実装者はinterfaceを実装(implements)するclassを作ります。

class CounterImpl implements Counter {
  private int value_;
  public CounterImpl() { value_ = 0; }
  // interface Counter を実装する
  public void incr() { ++value_; }
  public void decr() { --value_; }
  public int value() { return value_; }
}

利用者にCounterImplの存在を気づかせないために、Counterを生成するクラスCounterFactoryを用意しましょう。

public class CounterFactory {
  public static Counter create() { return new CounterImpl(); }
}

CounterFactory.create()はCounterImplをnewし、それをCounterとして返します。利用者にはCounterFactory.create()で手に入れたオブジェクトが実際にはCounterImplだということを隠しています。それでいいんです。利用者が欲しがっているのはCounterImplではなく、Counterに対する操作なのですから。

public class Client {
  public static void main(String[] arg) {
    Counter c = CounterFactory.create();
    for ( int i = 0; i < 3; ++i ) {
      c.incr();
      System.out.println("value= "+c.value());
    }
  }
}

Clientをアプレット化するとこんな感じになります。[1]

C++における抽象データ型

残念ながらC++ではJavaのinterfaceのような抽象データ型を直接にはサポートしていません。が、それと同等のことなら可能です。一切のメンバ変数を持たず、そして全メンバ関数を純粋仮想関数とするのです。

class Counter {
public:
  virtual ~Counter() {}
  virtual void incr() =0;
  virtual void decr() =0;
  virtual long value() const =0;
};

そしてこのCounterから派生したCounterImpl、およびCounterFactoryを作りましょう。

class CounterFactory {
public:
  static Counter* create();
  static void     release(Counter*);
};

/* --- ここから実装部。Counterの利用者には見せない --- */

class CounterImpl : virtual public Counter {
private:
  long value_;
public:
   CounterImpl() : value_(0) {}
   virtual void incr() { ++value_; }
   virtual void decr() { --value_; }
   virtual long value() const { return value_; }
};

Counter* CounterFactory::create() {
  return new CounterImpl;
}

void CounterFactory::release(Counter* c) {
   delete c;
}

利用者(Client)は以下のようになります。

using namespace std;

int main() {
  adt::Counter* c = adt::CounterFactory::create();
  for ( int i = 0; i < 3; ++i ) {
    c->incr();
    cout << "value= " << c->value() << endl;
  }
  adt::CounterFactory::release(c);
  return 0;
}

言語を越えて…

抽象データ型はその利用者と実装者との間の申し合わせです。これを発展させると、抽象データ型を利用者と実装者双方が認識できる、すなわち実装者はそのインタフェースをサポートするオブジェクトを生成し、利用者はそのインタフェースを提供するオブジェクトを手に入れて利用することができるなら、利用者と実装者が互いに異なる言語で書かれていてもいいはずです。それを実現したのがCOM、そしてCORBAです。

COM (Component Object Model)

Visual C++ 6.0 ATLを使ってCOMサーバ(実装側)を作ってみましょう。

Visual C++の”ATL COMAppWizard”を使えばCOMサーバをとっても簡単に作れます。

CounterのインタフェースICounterを作ってできたファイルadt.idlを以下に示します。

...
  interface ICounter : IDispatch {
    [id(1), helpstring("+1する")] HRESULT incr();
    [id(2), helpstring("-1する")] HRESULT decr();
    [propget, id(3), helpstring("値を返す")] HRESULT value([out, retval] long *pVal);
  };
...
  coclass Counter {
    [default] interface ICounter;
  };
...

adt.idlの中に、incr,decr,valueをサポートするインタフェースICounterと、ICounterをインタフェースとして持つクラスCounterがあることがわかるでしょう。

以下に示すのは最終的にできあがったCounterの実装部CCounterです。

class ATL_NO_VTABLE CCounter :
  public CComObjectRootEx,
  public CComCoClass,
  public IDispatchImpl<ICounter, &IID_ICounter, &LIBID_ADTLib> {
public:
  CCounter() { value_ = 0; }

DECLARE_REGISTRY_RESOURCEID(IDR_COUNTER)
DECLARE_PROTECT_FINAL_CONSTRUCT()

BEGIN_COM_MAP(CCounter)
  COM_INTERFACE_ENTRY(ICounter)
  COM_INTERFACE_ENTRY(IDispatch)
END_COM_MAP()

public:
  STDMETHOD(get_value)(long *pVal);
  STDMETHOD(decr)();
  STDMETHOD(incr)();
private:
  long value_;
};
/* --- implementation --- */

STDMETHODIMP CCounter::incr() {
  ++value_;
  return S_OK;
}

STDMETHODIMP CCounter::decr() {
  --value_;
  return S_OK;
}

STDMETHODIMP CCounter::get_value(long *pVal) {
  *pVal = value_;
  return S_OK;
}

これをコンパイルすればadt.dllができあがり、レジストリに登録されます。これでCOMをサポートする言語ならなんであれ、利用者はCounterを使うことができるはずです。

Visual BasicからCounterを使ってみましょうか。VisualBasicのメニューから”プロジェクト|参照設定”ることで、VisualBasicがCounterのインタフェースを認識します。

フォーム上にテキストボックス(txtValue)とボタンをふたつ(btnIncr,btnDecr)配置して:

Option Explicit

Private c As Counter

Private Sub btnDecr_Click()
  c.decr
  txtValue = c.Value
End Sub

Private Sub btnIncr_Click()
  c.incr
  txtValue = c.Value
End Sub

Private Sub Form_Load()
  Set c = New Counter
End Sub

Private Sub Form_Unload(Cancel As Integer)
  Set c = Nothing
End Sub

なんとまぁ、たったこれだけで動いてしまうんです。

CORBA (Common Object Request Broker Architecture

CORBAはインタフェースを利用者と実装者が共有するという考えをもう一歩すすめ、異なるマシン/異なるOS/異なるプロセス/異なる言語による利用者/実装者を可能にしてくれます。

Orbixを使ってCounterを作ります。まずはインタフェースの定義から。

module adt {
  interface Counter {
    void incr();
    void decr();
    readonly attribute long value;
  };
};

avaのinterfaceとそっくりです。このインタフェース定義ファイルadt.idlをIDLコンパイラに食わせると、利用者/実装者それぞれのためにスタブ/スケルトンを吐いてくれます。実装者はスケルトンを基にCounterを実装し、利用者はスタブを使ってCounterにアクセスします。

/*
 * interface Counter の実装
 */
#include "Counter.hh"

namespace adt {

  class CounterImpl : public virtual CounterBOAImpl {
  private:
    CORBA::Long value_;

  public:
    CounterImpl() : value_(0) {}

    virtual void incr(CORBA::Environment &IT_env=CORBA::default_environment) ;
    virtual void decr(CORBA::Environment &IT_env=CORBA::default_environment) ;
    virtual CORBA::Long value(CORBA::Environment &IT_env=CORBA::default_environment) ;
  };

}

namespace adt {

  void CounterImpl::incr(CORBA::Environment &IT_env) {
    ++value_;
  }

  void CounterImpl::decr(CORBA::Environment &IT_env) {
    --value_;
  }

  CORBA::Long CounterImpl::value(CORBA::Environment &IT_env)  {
    return value_;
  }

}

実装者(サーバ)は(COMをレジストリに登録するように)あらかじめOrbixデーモンに登録しておきます。利用者はデーモンの仲介でCounterを手に入れ、利用します。

/*
 * クライアント
 */
#include "Counter.hh"
#include 

int main() {
  adt::Counter_var c;
  c = adt::Counter::_bind(":adt");
  for ( int i = 0; i < 3; ++i ) {
    c->incr();
    cout << "value= " << c->value() << endl;
  }
  return 0;
}

注釈

^弊社のWebサイト公開ポリシーによりアプレットは削除しております。

XMLを用いた状態遷移 part-2

cpptechdoc — Fri, 14 Apr 2006 06:17:13 +0000

はじめに

前作XMLを用いた状態遷移では状態遷移表をXMLで記述し、それをXMLパーサで解析して状態遷移表のふるまいを動的に再現すると言う試みを紹介しました。

今回はここからさらに発展させ、XMLで記述された状態遷移表に基づいて、そこに表現されたとおりに振る舞うC++/Javaのソースコードを生成することを考えます。つまりはSMCのXML版です。SMCでは構文解析/字句解析にyacc/lexを用いていましたが、XMLで記述することで、yacc/lexから解放されました。

前回用いた例”(門番のいる)ゲート”の状態遷移表を再度示します。

現在の状態	イベント	次の状態	アクション
Locked	Coin	Unlocked	Unlock
Pass	Locked	Alarm
Unlocked	Coin	Unlocked	ThankYou
Pass	Locked	Lock

ゲートがLocked状態のとき:
- Coinイベントが発生したら、Unlocked状態に遷移してUnlockアクションを起こす。
- Passイベントが発生したら、閉じているゲートを無理矢理誰かが通過したことに対しAlarmアクションを起こす
ゲートがUnlocked状態のとき:
- Passイベントが発生したら、Locked状態に戻してLockアクションを起こす
- Coinイベントが発生したら、余分なお金を頂いた事に礼を言う(ThankYouアクションを起こす)。

状態遷移表のXMLによる表現

この状態遷移表のXMLによる記述は前作から少しばかり拡張されています。

文法

まず、状態遷移表をXMLで表現するための文法をDTD(Document Type Definition)で定義します。
これは今後いかなる状態遷移表をXMLで記述する場合でも再利用できます。

fsm.dtd : 状態遷移表の文法

タグはその要素として0または1個のタグに続いてタグを0個以上含みます。タグには適当なコメントを記述できます。
タグはname(名前),initial(初期状態),terminal(停止状態)、そしてpackage(パッケージ名)とheader(ヘッダディレクトリ)を属性に持ちます。name,initialは必須属性です。packageは生成するJava-packageを指定します。たとえば
name=”Gate” package=”jp.co.s34.fsm” とすると、生成されるコードはpackage
jp.co.s34.fsm.Gate に置かれます。なお、生成されるJavaコードは Context.java,
State.java, Fsm.java の3本です。また、C++コードはFSM名.h および FSM名.cpp
です。宣言/実装はすべて namespace FSM名 {…} で囲まれます。
headerは生成するC++コードの宣言部(ヘッダ)のディレクトリを指定します。たとえば name=”Gate”
header=”fsm” とすると、生成される実装部 fsm.cpp は #include “fsm/Gate.h”
します。
タグはその要素として0または1個のタグに続いてタグを0個以上含みます。タグには適当なコメントを記述できます。
タグはname(名前),enter(入場動作)およびexit(退場動作)を属性に持ちます。nameは必須属性です。
```
  
```
タグはその要素として0または1個のタグを含みます。
```
  
```
タグはname(名前),transition(次の状態),action(アクション)を属性に持ちます。nameは必須属性です。transitionを省略すると、そのイベントは状態の遷移を起こさず、入場動作/退場動作も行ないません。

文法に基づいた状態遷移表

では、この文法に基づいてゲートの状態遷移表をXMLで記述します。

gate.xml : ゲートの状態遷移表







  門番のいるゲート
  
    ゲートが閉じている
    
      ゲートを開ける
    
    
      不法侵入
    
  

  
    ゲートが開いている
    
      チップとして受け取る
    
    
      ゲートを閉じる

XSLスタイルシートを用意しました。

fsm.xsl : スタイルシート



  
    
      
        XMLによる状態遷移表
      
      
        
        
           の状態遷移
          
          
            
              初期状態
              
            
            
              停止状態
              
            
          
          Java source
            
            
..Context.java

            ..State.java
            ..FSM.java
            
          
          C++ source
            
            
.h

            .cpp
            
          

          
          
            状態 : 
            
            
            

              入場動作 : 
              退場動作 : 
            
            
            
            

              
            
              イベント
              アクション
              遷移先
              説明
            
            
                
                
                
                
              
            
            
            
            
          
          
          
          
※ 遷移先が空欄である場合、状態の変化がなく、入場/退場動作も行わないことを意味します

初期状態
停止状態

XML/XSLに対応したブラウザであれば、次のように整形されたドキュメントが表示されます。

スタイルシートによる整形(一部)

生成コードの駆動メカニズム

状態遷移表のとおりに振る舞うコードの生成に、”STATEパターン”と呼ばれるデザイン・パターンを用います。STATEパターンによる状態遷移表のからくりは以下のとおりです。

Context
まず、状態遷移表に現われるすべての
“red”>アクション(入場動作/退場動作を含む)を抽象メソッド(純粋仮想関数)として定義したクラスContextを用意します。(引数
FSM については後述)
```
class Context {
public:
  virtual void Lock(FSM*) =0;
  virutal void Unlock(FSM*) =0;
  ...
};
    
```
Contextに定義されたアクションが実際のコードの中でどうふるまうかは状態遷移表には書かれておらず、利用者がこのContextから導出した派生クラスで再定義します。
State
状態遷移表に現われるすべてのイベントをメソッドとするクラスStateを定義します。
```
class State {
public:
  virtual void Coin(FSM*);
  virtual void Pass(FSM*);
  ...
};
  
```
そして状態遷移表に現われる状態ひとつひとつをStateから導出します
```
class LockedState : public State {
public:
  virtual void Coin(FSM*);
  virtual void Pass(FSM*);
  ...
};

class UnockedState : public State {
public:
  virtual void Coin(FSM*);
  virtual void Pass(FSM*);
  ...
};
  
```
このように定義すれば、たとえばメソッドLockedState::Coin()はLocked状態においてCoinというイベントが発生したときの振る舞いに対応づける事ができます。メソッドの引数FSMにコンテキストを取得するメソッド
Context* getContext()、そして次の状態を設定するメソッド void setState(State*)
を用意しておけば、状態とイベントの組に対応するアクションの実行と次の状態への遷移をコード化できます。
```
void 状態State::イベント(FSM* fsm) {
  fsm->getContext()->アクション(fsm);
  fsm->setState(次の状態);
}
```
FSM
コンテキストおよび現在の状態を内包するくらすFSMを定義します。FSMには状態遷移表に現われる全イベントをメソッドとして定義し、また、全状態をstaticメンバとして内包します。
```
class FSM {
  Context* context_; // コンテキスト
  State*   state_;   // 現在の状態
  static   LockedState Locked_;
  static   UnockedState Unocked_;
public:
  void Coin();
  void Pass();
  ...
};
```
状態遷移表の各イベントに対応したメソッドでは、現在の状態を表す変数 state_ の同名のメソッドを呼び出します。状態とイベントの組に対応した振る舞いのため、状態State::イベント()に委譲するわけです。
```
void FSM::イベント() {
  state_->イベント(this);
}
```

C++

生成されたコード

Gate.h 宣言部

#ifndef __fsm_Gate_h__
#define __fsm_Gate_h__

namespace Gate {

class FSM;

class Context {
public:
  virtual void error(const char* state_name, const char* event_name) =0;
  virtual void Alarm(FSM* fsm) =0;
  virtual void EnterLocked(FSM* fsm) =0;
  virtual void EnterUnlocked(FSM* fsm) =0;
  virtual void ExitLocked(FSM* fsm) =0;
  virtual void ExitUnlocked(FSM* fsm) =0;
  virtual void Lock(FSM* fsm) =0;
  virtual void ThankYou(FSM* fsm) =0;
  virtual void Unlock(FSM* fsm) =0;
};

class State {
public:
  virtual const char* getName() const =0;
  virtual void enter(FSM* fsm);
  virtual void exit(FSM* fsm);
  virtual void Coin(FSM* fsm);
  virtual void Pass(FSM* fsm);
};

class LockedState : public State {
public:
  virtual const char* getName() const;
  virtual void enter(FSM* fsm);
  virtual void exit(FSM* fsm);
  virtual void Coin(FSM* fsm);
  virtual void Pass(FSM* fsm);
};

class UnlockedState : public State {
public:
  virtual const char* getName() const;
  virtual void enter(FSM* fsm);
  virtual void exit(FSM* fsm);
  virtual void Coin(FSM* fsm);
  virtual void Pass(FSM* fsm);
};

class FSM  {
  Context* context_;
  State*   state_;
  State*   newstate_;
  State*   terminal_;
  static LockedState Locked_;
  static UnlockedState Unlocked_;
public:
  FSM() { state_ = &Locked_; terminal_ = 0; }
  bool isTerminated() const { return state_ == terminal_; }

  void setContext(Context* context) { context_ = context; }
  Context* getContext() const { return context_; }

  void setNewState(State* state) { newstate_ = state; }
  State* getNewState() { return newstate_; }

  void setState(State* state) { state_ = state; }
  void setState() { state_ = newstate_; }
  State* getState() { return state_; }

  static State* Locked() { return &Locked_; }
  static State* Unlocked() { return &Unlocked_; }

  void Coin() { state_->Coin(this); }
  void Pass() { state_->Pass(this); }
};

}

#endif

Gate.cpp 実装部

#include "fsm/Gate.h"

namespace Gate {

void State::enter(FSM* fsm) {}
void State::exit(FSM* fsm) {}
void State::Coin(FSM* fsm) { fsm->getContext()->error(getName(), "Coin"); }
void State::Pass(FSM* fsm) { fsm->getContext()->error(getName(), "Pass"); }

const char* LockedState::getName() const {  return "Locked"; }
void LockedState::enter(FSM* fsm) { fsm->getContext()->EnterLocked(fsm); }
void LockedState::exit(FSM* fsm) { fsm->getContext()->ExitLocked(fsm); }

void LockedState::Coin(FSM* fsm) {
  Context* context = fsm->getContext();
  fsm->setNewState(fsm->Unlocked());
  context->Unlock(fsm);
  exit(fsm);
  fsm->setState();
  fsm->getState()->enter(fsm);
}

void LockedState::Pass(FSM* fsm) {
  Context* context = fsm->getContext();
  fsm->setNewState(this);
  context->Alarm(fsm);
  if ( fsm->getNewState() != this ) {
    exit(fsm);
    fsm->setState();
    fsm->getState()->enter(fsm);
  } else {
    fsm->setState();
  }
}

LockedState FSM::Locked_;

const char* UnlockedState::getName() const {  return "Unlocked"; }
void UnlockedState::enter(FSM* fsm) { fsm->getContext()->EnterUnlocked(fsm); }
void UnlockedState::exit(FSM* fsm) { fsm->getContext()->ExitUnlocked(fsm); }

void UnlockedState::Coin(FSM* fsm) {
  Context* context = fsm->getContext();
  fsm->setNewState(this);
  context->ThankYou(fsm);
  if ( fsm->getNewState() != this ) {
    exit(fsm);
    fsm->setState();
    fsm->getState()->enter(fsm);
  } else {
    fsm->setState();
  }
}

void UnlockedState::Pass(FSM* fsm) {
  Context* context = fsm->getContext();
  fsm->setNewState(fsm->Locked());
  context->Lock(fsm);
  exit(fsm);
  fsm->setState();
  fsm->getState()->enter(fsm);
}

UnlockedState FSM::Unlocked_;

}

利用者コード

main.cpp

#include 
#include 

#include "fsm/Gate.h"

using namespace std;

class GateContext : public Gate::Context {
public:
  virtual void error(const char* state_name, const char* event_name) {
    cout << "error state=" << state_name << " event=" << event_name << endl;
  }
  virtual void Alarm(Gate::FSM* fsm)     { cout << "金払え!!" << endl; }
  virtual void EnterLocked(Gate::FSM*)   { cout << "ゲートが閉まりました" << endl; }
  virtual void EnterUnlocked(Gate::FSM*) { cout << "ゲートが開きました" << endl; }
  virtual void ExitLocked(Gate::FSM*)    { cout << "閉じた状態を終わります" << endl; }
  virtual void ExitUnlocked(Gate::FSM*)  { cout << "開いた状態を終わります" << endl; }
  virtual void Lock(Gate::FSM*)          { cout << "ゲートを閉めます" << endl; }
  virtual void ThankYou(Gate::FSM*)      { cout << "ありがとうございます" << endl; }
  virtual void Unlock(Gate::FSM*)        { cout << "ゲートを開けます" << endl; }
};

int main() {
  GateContext context;
  Gate::FSM fsm;
  fsm.setContext(&context);

  while ( true ) {
    cout << fsm.getState()->getName() << endl;
    cout << "  enter an event :";
    string event_name;
    cin >> event_name;
    if ( event_name == "exit" ) break;
    else
    if ( event_name == "Coin" ) fsm.Coin();
    else
    if ( event_name == "Pass" ) fsm.Pass();
    else continue;

  }
  return 0;
}

Java

生成されたコード

Context.java

package jp.co.s34.fsm.Gate;

public interface Context {
  void error(String state_name, String event_name);
  void Alarm(FSM fsm);
  void EnterLocked(FSM fsm);
  void EnterUnlocked(FSM fsm);
  void ExitLocked(FSM fsm);
  void ExitUnlocked(FSM fsm);
  void Lock(FSM fsm);
  void ThankYou(FSM fsm);
  void Unlock(FSM fsm);
}

State.java

package jp.co.s34.fsm.Gate;

public abstract class State {
  abstract public String getName();
  public void enter(FSM fsm) {}
  public void exit(FSM fsm) {}
  public void Coin(FSM fsm) { fsm.getContext().error(getName(), "Coin"); }
  public void Pass(FSM fsm) { fsm.getContext().error(getName(), "Pass"); }
}

Fsm.java

package jp.co.s34.fsm.Gate;

class LockedState extends State {
  public String getName() { return "Locked"; }
  public void enter(FSM fsm) { fsm.getContext().EnterLocked(fsm); }
  public void exit(FSM fsm) { fsm.getContext().ExitLocked(fsm); }
  public void Coin(FSM fsm) {
    Context context = fsm.getContext();
    fsm.setNewState(fsm.Unlocked());
    context.Unlock(fsm);
    exit(fsm);
    fsm.setState();
    fsm.getState().enter(fsm);
  }
  public void Pass(FSM fsm) {
    Context context = fsm.getContext();
    fsm.setNewState(this);
    context.Alarm(fsm);
    if ( fsm.getNewState() != this ) {
      exit(fsm);
      fsm.setState();
      fsm.getState().enter(fsm);
    } else {
      fsm.setState();
    }
  }
}

class UnlockedState extends State {
  public String getName() { return "Unlocked"; }
  public void enter(FSM fsm) { fsm.getContext().EnterUnlocked(fsm); }
  public void exit(FSM fsm) { fsm.getContext().ExitUnlocked(fsm); }
  public void Coin(FSM fsm) {
    Context context = fsm.getContext();
    fsm.setNewState(this);
    context.ThankYou(fsm);
    if ( fsm.getNewState() != this ) {
      exit(fsm);
      fsm.setState();
      fsm.getState().enter(fsm);
    } else {
      fsm.setState();
    }
  }
  public void Pass(FSM fsm) {
    Context context = fsm.getContext();
    fsm.setNewState(fsm.Locked());
    context.Lock(fsm);
    exit(fsm);
    fsm.setState();
    fsm.getState().enter(fsm);
  }
}

public class FSM  {
  Context context_;
  State   state_;
  State   terminal_;
  State   newstate_;
  private final static LockedState Locked_ = new LockedState();
  private final static UnlockedState Unlocked_ = new UnlockedState();

  public FSM() { state_ = Locked_; terminal_ = null; }
  public boolean isTerminated() { return state_ == terminal_; }

  public void setContext(Context context) { context_ = context; }
  public Context getContext() { return context_; }

  public void setNewState(State state) { newstate_ = state; }
  public State getNewState() { return newstate_; }

  public void setState(State state) { state_ = state; }
  public void setState() { state_ = newstate_; }
  public State getState() { return state_; }
  public static State Locked() { return Locked_; }
  public static State Unlocked() { return Unlocked_; }

  public void Coin() { state_.Coin(this); }
  public void Pass() { state_.Pass(this); }
}

利用者コード

Gate.java

import jp.co.s34.fsm.Gate.*;
import java.io.*;

public class Gate implements Context {

  public void error(String state_name, String event_name) {
    System.out.println("error state=" + state_name +  " event=" + event_name);
  }
  public void Alarm(FSM fsm)         { System.out.println("金払え!!"); }
  public void EnterLocked(FSM fsm)   { System.out.println("ゲートが閉まりました"); }
  public void EnterUnlocked(FSM fsm) { System.out.println("ゲートが開きました"); }
  public void ExitLocked(FSM fsm)    { System.out.println("閉じた状態を終わります"); }
  public void ExitUnlocked(FSM fsm)  { System.out.println("開いた状態を終わります"); }
  public void Lock(FSM fsm)          { System.out.println("ゲートを閉めます"); }
  public void ThankYou(FSM fsm)      { System.out.println("ありがとうございます"); }
  public void Unlock(FSM fsm)        { System.out.println("ゲートを開けます"); }

  public static void main(String[] arg) throws Exception {
    Context context = new Gate();
    FSM     fsm = new FSM();
    fsm.setContext(context);

    BufferedReader input = new BufferedReader(new InputStreamReader(System.in));    while ( true ) {
      System.out.println(fsm.getState().getName());
      System.out.print("enter an event :");
      String event_name = input.readLine();
      if ( event_name.equals("exit") ) break;
      else
      if ( event_name.equals("Coin") ) fsm.Coin();
      else
      if ( event_name.equals("Pass") ) fsm.Pass();
      else continue;
    }

  }
}

イベント駆動型XMLパーサによるコード生成

アプリケーションの実装にはIBM alphaWorks XML4C(XML Paeser for C++) 3.0.1
が提供するイベント駆動型パーサを使いました。

XML上のエレメント//それぞれが持つ属性およびそれらの子エレメントを内包する3種の
struct を定義します。

struct Event {
  std::string name;        // 名前
  std::string action;      // アクション
  std::string transition;  // 次の状態
  ...
};

typedef std::set<Event> Events;

struct State {
  std::string name;  // 名前
  std::string enter; // 入場動作
  std::string exit;  // 退場動作
  Events events;     // Eventの集合
  ...
};

typedef std::set<State> States;

struct FSM {
  std::string name;     // 名前
  std::string initial;  // 初期状態
  std::string terminal; // 停止状態
  std::string package;  // package名(Java)
  std::string header;   // ヘッダディレクトリ(C++)
  States states;        // Stateの集合
};

パーサがタグの開始/終了を検出した時点でハンドラのメソッドstartElement()/endElement()が呼び出されますから、そこでタグ名に応じて上記
struct を組み立てます。

このようにして構築された struct は状態遷移表のすべての情報を包含していますから、“生成コードの駆動メカニズム”で解説したとおりのコードをファイルに書き出せばできあがりです。

fsm.cpp

/*
 * Finite State Machine code generator
 *  using XML4C/SAXParser (IBM XML Parser for C++ 3.0.1)
 */

#include 
#include 
#include 
#include 

#include     // PlatformUtils
#include      // SAXParser
#include        // HandlerBase
#include  // SaxParseException

#define LN "\n"

/*
 * UNICODEからstringへの変換
 */
inline std::string transcode(const XMLCh* xmlch) {
  return xmlch ? XMLString::transcode(xmlch) : "";
}

typedef std::set Names;

/*
 * Event
 */
struct Event {
  std::string name;        // 名前
  std::string action;      // アクション
  std::string transition;  // 次の状態
  Event() {}
  Event(const std::string& n) : name(n) {}
  Event(const std::string& n, const std::string& a, const std::string& t)
    : name(n), action(a), transition(t) {}
};

inline bool operator<(const Event& x, const Event& y) {
  return x.name < y.name;
}

typedef std::set Events;

/*
 * State
 */
struct State {
  std::string name;  // 名前
  std::string enter; // 入場動作
  std::string exit;  // 退場動作
  Events events;     // Eventの集合
  State() {}
  State(const std::string& n) : name(n) {}
};

inline bool operator<(const State& x, const State& y) {
  return x.name < y.name;
}

typedef std::set States;

/*
 * FSM
 */
struct FSM {
  std::string name;     // 名前
  std::string initial;  // 初期状態
  std::string terminal; // 停止状態
  std::string package;  // package名(Java)
  std::string header;   // ヘッダディレクトリ(C++)
  States states;        // Stateの集合
  Names state_names;
  Names event_names;
  Names action_names;
  Names transition_names;
};

/*
 * エラーメッセージの出力
 */
std::ostream& operator<<(std::ostream& stream, const SAXParseException& exception) {
  return stream << "public-id=" << transcode(exception.getPublicId())
                << " system-id=" << transcode(exception.getSystemId())
                << " line=" << exception.getLineNumber()
                << " column=" << exception.getColumnNumber()
                << " : " << transcode(exception.getMessage());
}

using namespace std;

/*
 * XMLからFSMを構築するためのハンドラ
 */
class Handler : public HandlerBase {
  State current_state;
  FSM&  fsm;
public:

  Handler(FSM& f) : fsm(f) {}

  // DocumentHandler

  // エレメント(タグ)の開始
  virtual void startElement(const XMLCh* const tag_name, AttributeList& attrs) {
    std::string tag = transcode(tag_name);
    std::string tmp;
    // 
    if ( tag == "FSM" ) {
      fsm.name     = transcode(attrs.getValue(L"name"));
      fsm.initial  = transcode(attrs.getValue(L"initial"));
      fsm.terminal = transcode(attrs.getValue(L"terminal"));
      fsm.package  = transcode(attrs.getValue(L"package"));
      fsm.header   = transcode(attrs.getValue(L"header"));
    } else
    // 
    if ( tag == "State" ) {
      current_state.name  = tmp = transcode(attrs.getValue(L"name"));
      if ( !tmp.empty() ) fsm.state_names.insert(tmp);
      current_state.enter = tmp = transcode(attrs.getValue(L"enter"));
      if ( !tmp.empty() ) fsm.action_names.insert(tmp);
      current_state.exit  = tmp = transcode(attrs.getValue(L"exit"));
      if ( !tmp.empty() ) fsm.action_names.insert(tmp);
      current_state.events.clear();
    } else
    // 
    if ( tag == "Event" ) {
      Event event;
      event.name = tmp = transcode(attrs.getValue(L"name"));
      if ( !tmp.empty() ) fsm.event_names.insert(tmp);
      event.action = tmp = transcode(attrs.getValue(L"action"));
      if ( !tmp.empty() ) fsm.action_names.insert(tmp);
      event.transition = tmp = transcode(attrs.getValue(L"transition"));
      if ( !tmp.empty() ) fsm.transition_names.insert(tmp);
      current_state.events.insert(event);
    }
  }

  // エレメント(タグ)の終了
  virtual void endElement(const XMLCh* const tag_name) {
    std::string tag = transcode(tag_name);
    // 
    if ( tag == "State" ) {
      fsm.states.insert(current_state);
    }
  }

  // ErrorHandler

  virtual void warning(const SAXParseException& exception)
    { cout << "warning: " << exception << endl; }

  virtual void error(const SAXParseException& exception)
    { cout << "error:   " << exception << endl; }

  virtual void fatalError(const SAXParseException& exception)
    { cout << "fatal:   " << exception << endl; }

};

/*
 * ----- main -----
 */
int main(int argc, char* argv[]) {

  FSM fsm;
  Events::const_iterator eit;
  States::const_iterator sit;
  Names::const_iterator  nit;

  /*
   * 初期化とFSMの構築
   */
  try {
    XMLPlatformUtils::Initialize();
    SAXParser parser;
    Handler   handler(fsm);

    parser.setDoValidation(true);        // DTDによる検証を行う
    parser.setDocumentHandler(&handler); // ハンドラ設定
    parser.setErrorHandler(&handler);    // 同上(エラー用)

    parser.parse(argv[1]);

  } catch ( const XMLException& er ) {
    cout << er.getMessage() << endl;
  }

  /*
   * 初期状態は定義されているか?
   */
  if ( fsm.state_names.find(fsm.initial) == fsm.state_names.end() ) {
    cerr << "invalid initial : " << fsm.initial << endl;
    return 1;
  }

  /*
   * 停止状態は定義されているか?
   */
  if ( !fsm.terminal.empty() && fsm.state_names.find(fsm.terminal) == fsm.state_names.end() ) {
    cerr << "invalid terminal : " << fsm.terminal << endl;
    return 1;
  }

  /*
   * 遷移先は定義されているか?
   */
  for ( nit = fsm.transition_names.begin(); nit != fsm.transition_names.end(); ++nit ) {
    if ( fsm.state_names.find(*nit) == fsm.state_names.end() ) {
      cerr << "invalid transition : " << *nit << endl;
      return 1;
    }
  }

  ofstream fout;

#include "cppgen.inc"  /* C++  コード生成部 */
#include "javagen.inc" /* Java コード生成部 */

  return 0;
}

cppgen.inc C++ コード生成部

  /*
   * C++ コードの生成
   */

  fout.open((fsm.name + ".h").c_str());

  /*
   * 宣言部 (ヘッダ)
   */
  if ( fsm.header.empty() ) {
    fout << "#ifndef __" << fsm.name << "_h__" LN
         << "#define __" << fsm.name << "_h__" LN LN;
  } else {
    fout << "#ifndef __" << fsm.header << '_' << fsm.name << "_h__" LN
         << "#define __" << fsm.header << '_' << fsm.name << "_h__" LN LN;
  }

  fout << "namespace " << fsm.name << " {" LN LN;

  /*
   * Context 宣言
   */
  fout << "class FSM;" LN LN
          "class Context {" LN "public:" LN
          "  virtual void error(const char* state_name, const char* event_name) =0;" LN;
  for ( nit = fsm.action_names.begin(); nit != fsm.action_names.end(); ++nit ) {
    fout << "  virtual void " << *nit << "(FSM* fsm) =0;" LN;
  }
  fout << "};" LN LN;

  /*
   * State(base) 宣言
   */
  fout << "class State {" LN "public:" LN
       << "  virtual const char* getName() const =0;" LN
       << "  virtual void enter(FSM* fsm);" LN
       << "  virtual void exit(FSM* fsm);" LN;
  for ( nit = fsm.event_names.begin(); nit != fsm.event_names.end(); ++nit ) {
    fout << "  virtual void " << *nit << "(FSM* fsm);" LN;
  }
  fout << "};" LN LN;

  /*
   * State 宣言
   */
  for ( sit = fsm.states.begin(); sit != fsm.states.end(); ++sit) {
    fout << "class " << sit->name << "State : public State {" LN "public:" LN
         << "  virtual const char* getName() const;" LN;
    if ( !sit->enter.empty() ) {
      fout << "  virtual void enter(FSM* fsm);" LN;
    }
    if ( !sit->exit.empty() ) {
      fout << "  virtual void exit(FSM* fsm);" LN;
    }
    for ( eit = sit->events.begin(); eit != sit->events.end(); ++eit ) {
      fout << "  virtual void " << eit->name << "(FSM* fsm);" LN;
    }
    fout << "};" LN LN;
  }

  /*
   * FSM 宣言
   */
  fout << "class FSM  {" LN
          "  Context* context_;" LN
          "  State*   state_;" LN
          "  State*   newstate_;" LN
          "  State*   terminal_;" LN;
  for ( nit = fsm.state_names.begin(); nit != fsm.state_names.end(); ++nit ) {
    fout << "  static " << *nit << "State " << *nit << "_;" LN;
  }
  fout << "public:" LN
          "  FSM() { state_ = &" << fsm.initial << "_; ";
  if ( fsm.terminal.empty() ) {
    fout << "terminal_ = 0; }" LN;
  } else {
    fout << "terminal_ = &" << fsm.terminal << "_; }" LN;
  }
  fout << "  bool isTerminated() const { return state_ == terminal_; }" LN LN
       << "  void setContext(Context* context) { context_ = context; }" LN
       << "  Context* getContext() const { return context_; }" LN LN
       << "  void setNewState(State* state) { newstate_ = state; }" LN
       << "  State* getNewState() { return newstate_; }" LN LN
       << "  void setState(State* state) { state_ = state; }" LN
       << "  void setState() { state_ = newstate_; }" LN
       << "  State* getState() { return state_; }" LN LN;
  for ( nit = fsm.state_names.begin(); nit != fsm.state_names.end(); ++nit ) {
    fout << "  static State* " << *nit << "() { return &" << *nit << "_; }" LN;
  }
  fout << LN;
  for ( nit = fsm.event_names.begin(); nit != fsm.event_names.end(); ++nit ) {
    fout << "  void " << *nit << "() { state_->" << *nit << "(this); }" LN;
  }
  fout << "};" LN LN;

  fout << "}" LN LN;
  fout << "#endif" LN;
  fout.close();

  /*
   * 実装部
   */
  fout.open((fsm.name + ".cpp").c_str());

  if ( fsm.header.empty() ) {
    fout << "#include \"" << fsm.name << ".h\"" LN LN;
  } else {
    fout << "#include \"" << fsm.header << '/' << fsm.name << ".h\"" LN LN;
  }

  fout << "namespace " << fsm.name << " {" LN LN;

  /*
   * Context 実装
   */
  // 実装すべきものはなにもない。

  /*
   * State(base) 実装
   */
  fout << "void State::enter(FSM* fsm) {}" LN
          "void State::exit(FSM* fsm) {}" LN;
  for ( nit = fsm.event_names.begin(); nit != fsm.event_names.end(); ++nit ) {
    fout << "void State::" << *nit
           << "(FSM* fsm) { fsm->getContext()->error(getName(), \"" << *nit << "\"); }" LN;
  }
  fout << LN;

  /*
   * State 実装
   */
  for ( sit = fsm.states.begin(); sit != fsm.states.end(); ++sit) {
    fout << "const char* " << sit->name << "State::getName() const {"
            "  return \"" << sit->name << "\"; }" LN;
    if ( !sit->enter.empty() ) {
      fout << "void " << sit->name << "State::enter(FSM* fsm) { fsm->getContext()->"
           << sit->enter << "(fsm); }" LN;
    }
    if ( !sit->exit.empty() ) {
      fout << "void " << sit->name << "State::exit(FSM* fsm) { fsm->getContext()->"
           << sit->exit << "(fsm); }" LN;
    }
    fout << LN;

    for ( eit = sit->events.begin(); eit != sit->events.end(); ++eit ) {
      fout << "void " << sit->name << "State::" << eit->name << "(FSM* fsm) {" LN
              "  Context* context = fsm->getContext();" LN;
      if ( eit->transition.empty() ) {
        fout << "  fsm->setNewState(this);" LN;
      } else {
        fout << "  fsm->setNewState(fsm->" << eit->transition << "());" LN;
      }
      if ( !eit->action.empty() ) {
        fout << "  context->" << eit->action << "(fsm);" LN;
      }
      States::const_iterator tit = eit->transition.empty() ? sit : fsm.states.find(State(eit->transition));

      if ( eit->transition.empty() ) {
        fout << "  if ( fsm->getNewState() != this ) {" LN
                "    exit(fsm);" LN
                "    fsm->setState();" LN
                "    fsm->getState()->enter(fsm);" LN
                "  } else {" LN
                "    fsm->setState();" LN
                "  }" LN;
      } else {
        if ( !sit->exit.empty() ) {
          fout << "  exit(fsm);" LN;
        }
        fout << "  fsm->setState();" LN;
        if ( !tit->enter.empty() ) {
          fout << "  fsm->getState()->enter(fsm);" LN;
        }
      }
      fout << "}" LN LN;
    }
    fout << sit->name << "State FSM::" << sit->name << "_;" LN LN;

  }

  fout << "}" LN;
  fout.close();

javagen.inc Java コード生成部

  /*
   * Java コードの生成
   */

  /*
   * Context.java
   */
  fout.open("Context.java");
  if ( fsm.package.empty() ) {
    fout << "package " << fsm.name << ";" LN LN;
  } else {
    fout << "package " << fsm.package << '.' << fsm.name << ";" LN LN;
  }

  fout << "public interface Context {" LN
       << "  void error(String state_name, String event_name);" LN ;
  for ( nit = fsm.action_names.begin(); nit != fsm.action_names.end(); ++nit ) {
    fout << "  void " << *nit << "(FSM fsm);" LN;
  }
  fout << "}" LN LN;
  fout.close();

  /*
   * State.java
   */
  fout.open("State.java");
  if ( fsm.package.empty() ) {
    fout << "package " << fsm.name << ";" LN LN;
  } else {
    fout << "package " << fsm.package << '.' << fsm.name << ";" LN LN;
  }

  /*
   * State(base)
   */
  fout << "public abstract class State {" LN
          "  abstract public String getName();" LN
          "  public void enter(FSM fsm) {}" LN
          "  public void exit(FSM fsm) {}" LN;
  for ( nit = fsm.event_names.begin(); nit != fsm.event_names.end(); ++nit ) {
    fout << "  public void " << *nit << "(FSM fsm) { fsm.getContext().error(getName(), \""
           << *nit << "\"); }" LN;
  }
  fout << "}" LN LN;
  fout.close();

  /*
   * FSM.java
   */
  fout.open("FSM.java");
  if ( fsm.package.empty() ) {
    fout << "package " << fsm.name << ";" LN LN;
  } else {
    fout << "package " << fsm.package << '.' << fsm.name << ";" LN LN;
  }

  /*
   * State
   */
  for ( sit = fsm.states.begin(); sit != fsm.states.end(); ++sit) {
    fout << "class " << sit->name << "State extends State {" LN
            "  public String getName() { return \"" << sit->name << "\"; }" LN;
    if ( !sit->enter.empty() ) {
      fout << "  public void enter(FSM fsm) { fsm.getContext()." << sit->enter << "(fsm); }" LN;
    }
    if ( !sit->exit.empty() ) {
      fout << "  public void exit(FSM fsm) { fsm.getContext()." << sit->exit << "(fsm); }" LN;
    }

    for ( eit = sit->events.begin(); eit != sit->events.end(); ++eit ) {
      fout << "  public void " << eit->name << "(FSM fsm) {" LN
              "    Context context = fsm.getContext();" LN;
      if ( eit->transition.empty() ) {
        fout << "    fsm.setNewState(this);" LN;
      } else {
        fout << "    fsm.setNewState(fsm." << eit->transition << "());" LN;
      }
      if ( !eit->action.empty() ) {
        fout << "    context." << eit->action << "(fsm);" LN;
      }
      States::const_iterator tit = eit->transition.empty() ? sit : fsm.states.find(State(eit->transition));

      if ( eit->transition.empty() ) {
        fout << "    if ( fsm.getNewState() != this ) {" LN
                "      exit(fsm);" LN
                "      fsm.setState();" LN
                "      fsm.getState().enter(fsm);" LN
                "    } else {" LN
                "      fsm.setState();" LN
                "    }" LN;
      } else {
        if ( !sit->exit.empty() ) {
          fout << "    exit(fsm);" LN;
        }
        fout << "    fsm.setState();" LN;
        if ( !tit->enter.empty() ) {
          fout << "    fsm.getState().enter(fsm);" LN;
        }
      }

      fout << "  }" LN;

    }
    fout << "}" LN LN;
  }

  /*
   * FSM
   */
  fout << "public class FSM  {" LN
          "  Context context_;" LN
          "  State   state_;" LN
          "  State   terminal_;" LN
          "  State   newstate_;" LN;
  for ( nit = fsm.state_names.begin(); nit != fsm.state_names.end(); ++nit ) {
    fout << "  private final static " << *nit
            << "State " << *nit << "_ = new " << *nit << "State();" LN;
  }
  fout << LN;
  fout << "  public FSM() { state_ = " << fsm.initial << "_; ";
  if ( fsm.terminal.empty() ) {
    fout << "terminal_ = null; }" LN;
  } else {
    fout << "terminal_ = " << fsm.terminal << "State_; }" LN;
  }
  fout << "  public boolean isTerminated() { return state_ == terminal_; }" LN LN
          "  public void setContext(Context context) { context_ = context; }" LN
          "  public Context getContext() { return context_; }" LN LN
          "  public void setNewState(State state) { newstate_ = state; }" LN
          "  public State getNewState() { return newstate_; }" LN LN
          "  public void setState(State state) { state_ = state; }" LN
          "  public void setState() { state_ = newstate_; }" LN
          "  public State getState() { return state_; }" LN;
  for ( nit = fsm.state_names.begin(); nit != fsm.state_names.end(); ++nit ) {
    fout << "  public static State " << *nit << "() { return " << *nit << "_; }" LN;
  }
  fout << LN;
  for ( nit = fsm.event_names.begin(); nit != fsm.event_names.end(); ++nit ) {
    fout << "  public void " << *nit << "() { state_." << *nit << "(this); }" LN;
  }
  fout << "}" LN LN;

  fout.close();

※サンプルを含む全ソースコードはここ。

Handle-Bodyイディオム : 参照カウントによる実装

cpptechdoc — Fri, 14 Apr 2006 06:09:40 +0000

オブジェクト(クラス)のメンバ変数や関数の引数に値を用いるか、あるいは参照(ポインタ)を用いるかはプログラマの頭を悩ませます。

一般には値の方が良い、とされています。なぜなら値は参照(ポインタ)よりシンプルだからです。

ポインタが一方から他方へ引き渡されたとき、一つの実体を複数の場所で共有することになります。このときプログラマは実体のライフタイム(その実体をどこで/いつdeleteするか)を厳密に管理しなければなりません。複雑に絡み合ったポインタを矛盾なく解きほぐすのは相当に神経を使う作業となります。

しかしながら一方で値には問題があります。ひとつには値のコピーはコスト高となることがあるのです。オブジェクト内部に数多くのメンバを内在するときなど、そのコピーに必要な時間と手間はポインタに較べて非常に大きくなります。また、値渡しとはコピーを作ってそれを他方に引き渡すことになります。引き渡された側ではその本体(コピー元)にアクセスすることができず、値渡しそのこと自体が誤りである場合も少なくありません。

Handle-Bodyは値と参照(ポインタ)の双方のメリットを活かすイディオム(定石)です。
Handle-Bodyイディオムによって、ポインタを値のように扱うことが可能となり、オブジェクトの共有やライフタイム管理、そしてコストのかからないコピーといったことが実現できます。

Handle-Bodyイディオム(Bridgeパターン)とは、インタフェースと実装とを分離するからくりです。

Handle(インタフェース)がBody(実装)をその内部に持ち、Handleのメソッド呼び出しはそのまま内包するBodyに送られます。
そしてこのとき、HandleがBodyをポインタとして内包するなら、Handleのメンバ変数はポインタひとつですから非常にコンパクトでコピーを非常に短く/速く行えます。

しかし、HandleがBodyの'単なるポインタ'をメンバとして持った場合、Handle間でのコピーはひとつの実体を複数のHandleが共有することとなり、冒頭で述べた共有された実体のライフタイム管理が複雑になります。

共有された実体のライフタイム管理問題の解決のため、'参照カウント'を導入しましょう。参照カウントとは、ひとつの実体に対していくつのオブジェクトが参照しているかを表す数です。参照カウントは、あるオブジェクトがその実体への参照を開始したとき+1され、その実体への参照の必要がなくなるとき(参照しているオブジェクトがデストラクトされるとき)に-1されます。
そして参照カウントが0となったとき、実体そのものをデストラクトするからくりを用意するのです。

参照カウントを介して実体にアクセスすれば、プログラマはもはや実体の破壊タイミングを気にする必要はなくなります。複数のオブジェクトがひとつの実体を参照しているとき、最後のひとつのオブジェクトが参照を必要としなくなった瞬間、実体が自動的に破壊されます。
参照カウントは極めてにシンプルなガベジ・コレクタとして機能します。

HandleがBodyの参照カウントを保持することで値と参照(ポインタ)の双方のメリットを利用できるわけです。

参照カウントによる共有ポインタの実装のひとつがBoostのshared_ptrです。

shared_ptrはクラス・テンプレートであり、たとえば boost::shared_ptrはXへの共有ポインタとなります。

shared_ptr間のコピーは内包するポインタへの参照カウントを+1し、shared_ptrのデストラクタは参照カウント-1します。そして参照カウントが0となったとき、ポインタがdeleteされます。

{
  boost::shared_ptr p0(new int(123)); // [*] 参照数:1
  {
    boost::shared_ptr p1 = p0; // 参照数:2
    std::cout << *p1 << std::endl;
    // ここでp1が破壊され、参照数:1
  }
  // ここでp0が破壊され、参照数:0 -> [*] で作られたintが解放される。
}

boost::shared_ptrを利用してHandle-Bodyイディオムの単純な実装を試みました。

HandleとBodyの基底クラス

BodyBase.h

#ifndef BODYBASE_H
#define BODYBASE_H

#include  // noncopyable

/*
 * BodyBase
 */
class BodyBase : public boost::noncopyable {
public:
  virtual ‾BodyBase() {}
};

#endif

HandleBase.h

#ifndef HANDLEBASE_H
#define HANDLEBASE_H

#include  // shared_ptr
#include "BodyBase.h"

/*
 * HandleBase
 */
class HandleBase {
  boost::shared_ptr body_;
protected:
  HandleBase() {}
  HandleBase(BodyBase* p) : body_(p) {}
  BodyBase& body() const { return *body_; }
};

#endif

実装したHandle-Bodyを利用したサンプルを示します

サンプル

GreeterImpl.h

#ifndef GREETERIMPL_H
#define GREETERIMPL_H

#include 

#include "Greeter.h"

// abstract
class GreeterImpl : public BodyBase {
public:
  virtual void greet() const =0;
};

// concrete
class GreeterJa : public GreeterImpl {
  virtual void greet() const;
  GreeterJa();
  ‾GreeterJa();
public:
  static Greeter make();
};

// concrete
class GreeterEn : public GreeterImpl {
  virtual void greet() const;
  GreeterEn();
  ‾GreeterEn();
public:
  static Greeter make();
};

#endif

Greeter.h

#ifndef GREETER_H
#define GREETER_H

#include "HandleBase.h"

class GreeterImpl;

class Greeter : public HandleBase {
  GreeterImpl& body() const;
public:
  Greeter() {}
  Greeter(const Greeter& other) : HandleBase(other) {}
  Greeter(GreeterImpl* impl);
  void greet();
};

#endif

GreeterImpl.cpp

#include "GreeterImpl.h"

void GreeterJa::greet() const
{ std::cout << "こんにちは" << std::endl; }

GreeterJa::GreeterJa()
{ std::cout << "おはようございます" << std::endl; }

GreeterJa::‾GreeterJa()
{ std::cout << "おやすみなさい" << std::endl; }

Greeter GreeterJa::make()
{ return Greeter(new GreeterJa); }

void GreeterEn::greet() const
{ std::cout << "Hello!" << std::endl; }

GreeterEn::GreeterEn()
{ std::cout << "Good morning." << std::endl; }

GreeterEn::‾GreeterEn()
{ std::cout << "Good night." << std::endl; }

Greeter GreeterEn::make()
{ return Greeter(new GreeterEn); }

Greeter.cpp

#include "Greeter.h"
#include "GreeterImpl.h"

Greeter::Greeter(GreeterImpl* impl) : HandleBase(impl) {}

GreeterImpl& Greeter::body() const {
  return static_cast(HandleBase::body());
}

void Greeter::greet() {
  body().greet();
}

trial.cpp

#include 

#include "GreeterImpl.h"

/*
 * TRIAL
 */
int main() {
  Greeter g;

  {
  std::cout << "--- create GreeterJa" << std::endl;
  Greeter j = GreeterJa::make();
  g = j;
  }
  g.greet();

  {
  std::cout << "--- create GreeterEn" << std::endl;
  Greeter e = GreeterEn::make();
  g = e;
  }
  g.greet();

  return 0;
}

実行結果

--- create GreeterJa
おはようございます
こんにちは
--- create GreeterEn
Good morning.
おやすみなさい
Hello!
Good night.

はじめてのDBTools.h++ (part-2)

cpptechdoc — Fri, 14 Apr 2006 05:39:58 +0000

結合された複数テーブルからの読み出し

[part-1]に引き続き、DBTools.h++を使ったRDBの操作法に関する解説を続けます。

[part-1]ではひとつのテーブルに対するレコードの追加/変更/削除/検索を行ないました。では、結合された複数のテーブルから検索条件を指定して読み出してみる事にしましょう。

デモンストレーションのために、次のようなデータを用意しました。

NAME	KIND	HEADER
accumulate	function	numeric
adjacext_difference	function	numeric
adjacext_find	function	algorithm
…	…	…

これはStandard Template Libraryが提供する関数/構造体/クラスの

NAME : 名前
KIND : 種別 (関数/構造体/クラス)
HEADER : 宣言されているヘッダ

を一覧にした表です。まず各フィールドを以下のような3つのテーブルに分割しました。

T_STL
フィールド名	型	サイズ
NAME	CHAR	32
KIND_ID	LONG	4
HEAD_ID	LONG	4

T_KIND
フィールド名	型	サイズ
ID	LONG	4
NAME	CHAR	8

T_HEAD
フィールド名	型	サイズ
ID	LONG	4
NAME	CHAR	16

T_STLには関数/構造体/クラスの名前と、種別/ヘッダのIDが格納されます。種別/ヘッダ名はそれぞれT_KIND/T_HEADのIDに対応するNAMEフィールドに格納します。

これらのテーブルから、元の形式のデータを手に入れるには、

T_STL.KIND_ID と T_KIND.ID が等しく

かつ

T_STL.HEAD_ID と T_HEAD.ID が等しい

であるようなレコードの組み合わせから、

T_STL.NAME と T_KIND.NAME と T_HEAD.NAME を抽出すればいいわけです。

SQLで表現すると:

SELECT T_STL,NAME, T_KIND.NAME, T_HEAD.NAME
FROM   T_STL, T_KIND, T_HEAD
WHERE  T_STL.KIND_ID = T_KIND.ID AND T_STL.HEAD_ID = T_HEAD.ID

となります。

これをDBTools.h++で実現してみましょう。DBTools.h++による複数テーブルからの検索は、単一テーブルからの検索と何ら変わるところがありません。

まずデータベースをオープンし、テーブルを用意します。

  RWDBDatabase db_;
  RWDBTable    stl_;
  RWDBTable    kind_;
  RWDBTable    head_;

  db_ = RWDBManager::database(
     // serverType, serverName,  userName, password, databaseName
        SERVER,     "MASTER",    "FRUIT",  "APPLE",  "LIBRARIES"
        );

  stl_  = db_.table("T_STL");
  kind_ = db_.table("T_KIND");
  head_ = db_.table("T_HEAD");

つぎにデータベースからselectorを手に入れ、抽出フィールドと検索条件を設定します。

  RWDBSelector selector_;

  selector_ = db_.selector();
  selector_ << stl_["NAME"] << kind_["NAME"] << head_["NAME"];
  selector_.where(stl_["KIND_ID"] == kind_["ID"] &&
                  stl_["HEAD_ID"] == head_["ID"])

あとはselectorから得られたreaderを使ってフィールドを取り出します。

  RWDBReader reader_;
  reader_ = selector_.reader();
  while ( reader_() ) {
    RWCString name, kind, header;
    reader_ >> name >> kind >> header;
    ....
  }

自己結合

上の例は、複数のテーブル上の特定のフィールドを他のテーブルのフィールドと結合させています(内部結合:Inner Join)。

次の例では、あるフィールドを"同じテーブル"のフィールドと結合させます(自己結合:Self Join)。

T_FAMILY
フィールド名	型	サイズ
ID	LONG	4
NAME	CHAR	8
FATHER_ID	LONG	4

このテーブルには、ある人のIDと名前、そしてその人の父親のIDが定義されています。そして父親のレコードもまた、同じテーブル上に格納するものとします。

このとき、親子関係にある二人の名前の組を検索してみましょう。

SQLでは以下のようになります:

SELECT first.NAME, second.NAME
FROM   T_FAMILY first, T_FAMILY second
WHERE  first.ID = second.FATHER_ID

DBTools.h++では、ひとつのテーブルから複数のRWDBTableを作ることで実現します:

RWDBTable first  = db.table("T_FAMILY");
RWDBTable second = db.table("T_FAMILY");
RWDBSelector select = db.selector();
select << first["NAME"] << second["NAME"];
select.where(first["ID"] == second["FATHER_ID"]);

カーソルによるナビゲーション

前の例ではselectorからreaderを取り出していましたが、これでは最初のレコードから順に取り出す事しかできません。

カーソルを使えば、上のようにして得られたレコードの集合に対し、

最初のレコード
最後のレコード
次のレコード
前のレコード

を取り出すことができます。

まず、selectorからcursorを手に入れます。

  RWDBCursor cursor_;
  cursor_ = selector_.cursor(RWDBCursor::Scrolling);

selectorのメソッドcursorの引数としてRWDBCursor::Scrollingを与えています。これを省略するとRWDBCursor::Sequentialとみなされ、順次読み出ししかできません。

次にカーソルから読み出されるデータを変数にアタッチします。

  RWCString name, kind, header;
  cursor << &name << &kind << &header;

これによって、カーソルが移動すると同時にカーソルがポイントするレコードの各フィールドの内容が変数にセットされます。

カーソルの移動はfetchRow()メソッドで行ないます。

cursor_.fetchRow(RWDBCursor::First); //
先頭へ
cursor_.fetchRow(RWDBCursor::Last); //
末尾へ
cursor_.fetchRow(RWDBCursor::Next); //
次へ
cursor_.fetchRow(RWDBCursor::Previous);
// 前へ

下図のようなアプリケーションを作ってみました。

ダイアログの中ほどにある4つのボタンで先頭/前/次/末尾に移動します。

ソースコードは以下のようになります。

// ------------- definition ---
#ifndef _DBTOOLSDLG_H_
#define _DBTOOLSDLG_H_

class DBToolsDlg : public CDialog {
private:
    RWDBDatabase db_;
    RWDBTable    stl_;
    RWDBTable    kind_;
    RWDBTable    head_;
    RWDBSelector selector_;
    RWDBCursor   cursor_;

    static CDialog* self_;

private:
    static void onError(const RWDBStatus& status);
    void initDB();  // データベースとの接続
    void display(); // 検索結果の表示

public:
    DBToolsDlg(CWnd* pParent = NULL);

    //{{AFX_DATA(DBToolsDlg)
    enum { IDD = IDD_DBTOOLS_4_DIALOG };
    //}}AFX_DATA

    //{{AFX_VIRTUAL(DBToolsDlg)
    //}}AFX_VIRTUAL

protected:
    HICON m_hIcon;

    //{{AFX_MSG(DBToolsDlg)
    virtual BOOL OnInitDialog();
    afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
    afx_msg void OnPaint();
    afx_msg HCURSOR OnQueryDragIcon();
    afx_msg void OnFirst();  // 先頭レコードへ
    afx_msg void OnLast();   // 末尾レコードへ
    afx_msg void OnNext();   // 次のレコードへ
    afx_msg void OnPrev();   // 前のレコードへ
    afx_msg void OnSearch(); // 検索開始
    //}}AFX_MSG
    DECLARE_MESSAGE_MAP()
};

#endif

// ------------- implementation ---
#include "stdafx.h"
#include "DBTools_4.h"
#include "DBToolsDlg.h"

DBToolsDlg::DBToolsDlg(CWnd* pParent /*=NULL*/)
  : CDialog(DBToolsDlg::IDD, pParent) {
    //{{AFX_DATA_INIT(DBToolsDlg)
    //}}AFX_DATA_INIT
    m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
    self_ = this;
}

BEGIN_MESSAGE_MAP(DBToolsDlg, CDialog)
    //{{AFX_MSG_MAP(DBToolsDlg)
    ON_WM_SYSCOMMAND()
    ON_WM_PAINT()
    ON_WM_QUERYDRAGICON()
    ON_BN_CLICKED(IDC_FIRST, OnFirst)
    ON_BN_CLICKED(IDC_LAST, OnLast)
    ON_BN_CLICKED(IDC_NEXT, OnNext)
    ON_BN_CLICKED(IDC_PREV, OnPrev)
    ON_BN_CLICKED(IDC_SEARCH, OnSearch)
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()

void DBToolsDlg::OnSysCommand(UINT nID, LPARAM lParam) {
  if ((nID & 0xFFF0) == IDM_ABOUTBOX) {
    CAboutDlg dlgAbout;
    dlgAbout.DoModal();
  } else {
    CDialog::OnSysCommand(nID, lParam);
  }
}

void DBToolsDlg::OnPaint() {
  if (IsIconic()) {
    CPaintDC dc(this); // 描画用のデバイス コンテキスト
    SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
    CRect rect;
    GetClientRect(&rect);
    int x = (rect.Width() - GetSystemMetrics(SM_CXICON) + 1) / 2;
    int y = (rect.Height() - GetSystemMetrics(SM_CYICON) + 1) / 2;
    dc.DrawIcon(x, y, m_hIcon);
  } else {
    CDialog::OnPaint();
  }
}

HCURSOR DBToolsDlg::OnQueryDragIcon() {
    return (HCURSOR) m_hIcon;
}

/*
 * サーバ・タイプ: Debug mode   - msq15d.dll
 *                 Release mode - msq12d.dll
 */
#ifdef RWDEBUG
#define SERVER "msq15d.dll"
#else
#define SERVER "msq12d.dll"
#endif

CDialog* DBToolsDlg::self_ = 0;

namespace {

  void none(const RWDBStatus&) {
    // nothing to do...
  }

  inline void set_bitmap(CWnd* wnd, UINT n) {
    HBITMAP bmp = LoadBitmap(AfxGetInstanceHandle(),MAKEINTRESOURCE(n));
    static_cast(wnd)->SetBitmap(bmp);
  }

  struct record {
    RWCString name;
    RWCString kind;
    RWCString head;
    void clear() { name = ""; kind = ""; head = ""; }
  } rec;
}

BOOL DBToolsDlg::OnInitDialog() {
  CDialog::OnInitDialog();

  ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
  ASSERT(IDM_ABOUTBOX < 0xF000);
  CMenu* pSysMenu = GetSystemMenu(FALSE);
  if (pSysMenu != NULL) {
    CString strAboutMenu;
    strAboutMenu.LoadString(IDS_ABOUTBOX);
    if (!strAboutMenu.IsEmpty()) {
      pSysMenu->AppendMenu(MF_SEPARATOR);
      pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
    }
  }

  SetIcon(m_hIcon, TRUE);
  SetIcon(m_hIcon, FALSE);

  set_bitmap(GetDlgItem(IDC_FIRST),IDB_FIRST);
  set_bitmap(GetDlgItem(IDC_PREV), IDB_PREV);
  set_bitmap(GetDlgItem(IDC_NEXT), IDB_NEXT);
  set_bitmap(GetDlgItem(IDC_LAST), IDB_LAST);

  initDB();
  SetDlgItemText(IDC_PATTERN, "%");
  static_cast(GetDlgItem(IDC_RNAME))->SetCheck(1);
  OnSearch();
  return TRUE;
}

// データベースとの接続とテーブルの取得
void DBToolsDlg::initDB() {
  RWDBManager::setErrorHandler(onError);

  db_ = RWDBManager::database(
     // serverType, serverName,   userName, password, databaseName
        SERVER,     "GATEWAY_FF", "sa",     "",       "TRIAL"
        );

  stl_  = db_.table("T_STL");
  kind_ = db_.table("T_KIND");
  head_ = db_.table("T_HEAD");
}

// 先頭レコードへ
void DBToolsDlg::OnFirst() {
  cursor_.fetchRow(RWDBCursor::First);
  display();
}

// 末尾レコードへ
void DBToolsDlg::OnLast() {
  cursor_.fetchRow(RWDBCursor::Last);
  display();
}

// 次のレコードへ
void DBToolsDlg::OnNext() {
  if ( cursor_.fetchRow(RWDBCursor::Next).isValid() )
    display();
  else {
    MessageBeep(0);
    OnLast();
  }
}

// 前のレコードへ
void DBToolsDlg::OnPrev() {
  if ( cursor_.fetchRow(RWDBCursor::Previous).isValid() )
    display();
  else {
    MessageBeep(0);
    OnFirst();
  }
}

// レコードの表示
void DBToolsDlg::display() {
  SetDlgItemText(IDC_NAME, rec.name.data());
  SetDlgItemText(IDC_KIND, rec.kind.data());
  SetDlgItemText(IDC_HEAD, rec.head.data());
}

// エラーハンドラ : エラーメッセージを出力
void DBToolsDlg::onError(const RWDBStatus& aStatus) {
  if ( aStatus.errorCode() != RWDBStatus::ok ) {
    AfxMessageBox(aStatus.message().data());
    self_->EndDialog(IDCANCEL);
  }
}

// 検索
void DBToolsDlg::OnSearch() {

  RWDBColumn column;
  switch ( GetCheckedRadioButton(IDC_RNAME,IDC_RHEAD) ) {
  case IDC_RHEAD :
    column = head_["NAME"]; break;
  case IDC_RKIND :
    column = kind_["NAME"]; break;
  case IDC_RNAME : // no break, fall through...
  default:
    column = stl_["NAME"]; break;
  }

  /* 生成されるSQL文は:
   *
   * SELECT
   *   T_STL,NAME,
   *   T_KIND.NAME,
   *   T_HEAD.NAME
   * FROM
   *   T_STL,
   *   T_KIND,
   *   T_HEAD
   * WHERE
   *   T_STL.KIND_ID = T_KIND.ID
   *     AND
   *   T_STL.HEAD_ID = T_HEAD.ID
   *     AND
   *   COLUMN LIKE 'STRING'
   * ORDER BY
   *   COLUMN ASC
   *
   * と等価である。
   * なお 上記SQLにおいて COLUMN, 'STRING' はユーザが設定する
   */

  CString key;
  GetDlgItemText(IDC_PATTERN, key);
  RWDBCriterion join = stl_["KIND_ID"] == kind_["ID"] &&
                       stl_["HEAD_ID"] == head_["ID"];
  selector_ = db_.selector();
  selector_ << stl_["NAME"] << kind_["NAME"] << head_["NAME"];
  selector_.where(join && column.like(static_cast(key)));
  selector_.orderBy(column);

  // 生成されたSQL文を表示
  SetDlgItemText(IDC_SQL, selector_.asString());
  /*
   * 次のようなSQL文が生成される:
   *
   * SELECT
   *   t3.NAME,
   *   t4.NAME,
   *   t5.NAME
   * FROM
   *   T_STL t3,
   *   T_KIND t4,
   *   T_HEAD t5
   * WHERE
   *   t3.KIND_ID = t4.ID
   *     AND
   *   t3.HEAD_ID = t5.ID
   *     AND
   *   t3.NAME LIKE '%'
   * ORDER BY
   *   t3.NAME ASC
   */

  // カーソルを取得
  cursor_ = selector_.cursor(RWDBCursor::Scrolling);
  cursor_ << &rec.name << &rec.kind << &rec.head;
  cursor_.setErrorHandler(none);
  rec.clear();
  // 先頭レコードへ
  OnFirst();
}

トランザクション

複数のテーブルでひとつのデータの組を表現しているとき、データの更新(追加/削除/変更)を行なうには、当然ながら複数のテーブルに対して追加/削除/変更しなければなりません。

このとき、いずれかのテーブルの更新に失敗したとき、他のテーブルに対して行なった更新をキャンセルしてあげないと、データの整合が狂ってしまいます。すなわち、対象となる全テーブルの更新が成功しなかったときは、更新前の状態に戻してあげなければなりません。

DBTools.h++ではconnectionを使って変更の確定とキャンセルを行ないます。

データベースからconnectionを手に入れます。

  RWDBConnection con;
  con = db_.connection();
  con.autoCommit(false);

テーブルの更新に先立って、トランザクションを開始します。

  con.beginTransaction();

以後、テーブルに対する操作(追加/削除/変更)は、connectionを引数に渡します。

たとえばレコードの追加であれば:

  RWDBInserter inserter = stl_.inserter();
  //          NAME , KIND_ID, HEAD_ID
  inserter << "some_function" << 10 << 4;
  inserter.execute(con);

もし一連のテーブルの更新の途中でエラーが発生したとき、

  con.rollbackTransaction();

すれば、全テーブルの内容は con.beginTransaction() を行なった時点の状態まで巻き戻されます。

全テーブルの更新が成功したときは

  con.commitTransaction();

することで、全テーブルの内容が"確定"します。

エラーハンドラと例外を使えば、一連のトランザクション処理を以下のように書く事ができます:

void onError(const RWDBStatus& aStatus) {
  // エラーが発生したら例外をthrowする
  if ( aStatus.errorCode() != RWDBStatus::ok )
    aStatus.raise();
}

...
// エラーハンドラを設定する
RWDBManager::setErrorHandler(onError);

RWDBConnection con = db_.connection();
con.autoCommit(false);
try {
  con.beginTransaction();
  // テーブル更新処理
  // ...
  con.commitTransaction();
} // エラーが発生したらロールバック(巻き戻し)する
catch ( RWExternalErr&) {
  con.rollbackTransaction();
}

一括読み出し/書き込み

テーブルに対するレコードの読み出し/追加にはRWDBReader/REDBInserterを使います。が、RWDBReader/RWDBInserterは読み出し/書き込みごとにRDBへのアクセスを行ないます。したがって、大量のレコードを読み出す/書き込むときにはRDBへのアクセス回数が非常に多いため、パフォーマンスに問題があります。RWDBBulkReader/RWBulkInserterを使えば、一回のRDBアクセスで複数のレコードを一気に読み込む/書き込むことができます。

RWDBConnection con = db_.connection();

// 10レコードづつ一括読み込み
RWDBBulkReader bulk_r = stl_.bulkReader(con);
RWDBStringVector names(10, 32); // 32文字の文字列を10個分
RWDBVector kinds(10);
RWDBVector heads(10);
bulk_r << names << kinds << heads;

int numsRead = 0;
while ( (numsRead = bulk_r()) != 0 ) {
  for ( int i = 0; i << numsRead; ++i ) {
    cout << names[i] << ' '
         << kinds[i] << ' '
         << heads[i]
         << endl;
  }
}

// 10レコード一括書き込み
RWDBBulkInserter bulk_i = stl_.bulkInserter(con);
bulk_i << names << kinds << heads;
for ( int i = 0; i < 10; ) {
  names[i] = ...
  kinds[i] = ...
  heads[i] = ...
}
bulk_i.execute();

プライマリ・キー(PrimaryKey)と外部キー(Foreign Key)

テーブルの作成時、フィールドにプライマリ・キー(Primary Key)を設定することにより、データベースのパフォーマンスを向上させることができます。

また、そのプライマリ・キーを別のテーブルのフィールドの外部キーに設定しておけば、テーブル間の整合を保つことができます。

  // T_KIND のスキーマ定義
  RWDBSchema  kindSchema;

  RWDBColumn kind_id;
  kind_id.name("ID").type(RWDBValue::Long).nullAllowed(FALSE);
  kindSchema.appendColumn(kind_id);

  RWDBColumn kind_name;
  kind_name.name("NAME").type(RWDBValue::String).nullAllowed(FALSE).storageLength(8);
  kindSchema.appendColumn(kind_name);

  // ID を T_KIND のプライマリ・キーに設定する
  RWDBSchema  primeKey;
  primeKey.appendColumn(kindSchema["ID"]);
  kindSchema.primaryKey(primeKey);

  // テーブル T_KIND を作成
  db_.createTable("T_KIND", kindSchema);

  // T_STL のスキーマ定義
  RWDBSchema stlSchema;

  RWDBColumn stl_name;
  stl_name.name("NAME").type(RWDBValue::String).nullAllowed(FALSE).storageLength(50);
  stlSchema.appendColumn(stl_name);

  RWDBColumn stl_kind_id;
  stl_kind_id.name("KIND_ID").type(RWDBValue::Long).nullAllowed(FALSE);
  stlSchema.appendColumn(stl_kind_id);

  RWDBColumn stl_head_id;
  stl_head_id.name("HEAD_ID").type(RWDBValue::Long).nullAllowed(FALSE);
  stlSchema.appendColumn(stl_head_id);

  // T_KIND.ID を T_STL.KIND_ID の外部キーに設定する
  RWDBForeignKey keyToKind("KIND_ID");
  keyToKind.appendColumn(kindSchema["ID"]);
  stlSchema.foreignKey(keyToKind);

  // テーブル T_STL を作成
  db_.createTable("T_STL", stlSchema);

マルチスレッド環境下での排他制御

複数のクライアントからの要求に応じてデータベースの操作を行なうアプリケーションを想定してみてください。クライアントからのいくつもの要求に迅速に対応するには、マルチスレッド化が不可欠となります。しかし、その場合同一のテーブルに対するレコードの追加/削除/変更および検索要求がいくつも飛び込んできます。このとき、それぞれの要求に対してきちんと排他制御を行なわないとテーブルの不整合が発生したり、誤った検索結果を返すことになるでしょう。

DBTools.h++はスレッド間の競合を防ぐため、基本的な排他制御メカニズムを提供しています。

DBTools.h++の提供する多くのクラスには、メソッドacquire()とrelease()が定義されています。

acquire()によってそのオブジェクトの使用権を取得します。このとき、他のスレッドによって使用中であった場合、そのオブジェクトが使用可能となるまでブロックされます(acquire()から戻ってこない)。

release()によってそのオブジェクトの使用権を放棄します。acquire()でブロックしているスレッドがあれば、そのスレッドが動き始めます。

このメカニズムを利用すれば、ある瞬間においてオブジェクトを使用しているスレッドをひとつだけに制限する、すなわち排他制御が可能となります。

RWDBConnection sharedConn;

void foo(const RWDBDatabase& database) {
  sharedConn.acquire();
  {
    RWDBStoredProc sp = database::storedProc("myProc", sharedConn);
    sp.execute(sharedConn);
  }
  sharedConn.release();
  return;
}

上記の例は、ストアド・プロシージャを実行するものです。ストアド・プロシージャの実行に先立ちsharedConnに対してacquire()することで、sharedConnの使用権を取得しています。その後saredConn.release()されるまでは、他のスレッドがsharedConnを使うことができません。こうすることで、ストアド・プロシージャに対し、それを実行するスレッドはただ一つであることを保証します。

ただし、このコードには小さな穴があいています。acuire()からrelease()までの間に例外が発生した場合です。例外が発生すると、この関数のreturnに到達することなく、catchブロックに飛び込みます。したがってこの関数のreturnの直前にあるrelease()が呼ばれることはなく、結果的にsharedConnは使用権が解放されないままになってしまい、その後いかなるスレッドもこの関数をコールしたとたんブロックされることでしょう。

このようなデッドロックを避けるには、この関数の中で例外を捕まえ、そこでrelease()することになるでしょう。

RWDBConnection sharedConn;

void foo(const RWDBDatabase& database) {
  sharedConn.acquire();
  try {
    RWDBStoredProc sp = database::storedProc("myProc", sharedConn);
    sp.execute(sharedConn);
  } catch ( RWExternalErr&) {
    sharedConn.release();
    throw; // 再throw
  }
  sharedConn.release();
  return;
}

Guardクラスを用意し、そのコンストラクタでacquire(),デストラクタでrelease()すると便利です。

RWDBConnection sharedConn;

template
class Guard {
  T& object_;
public:
  Guard(const T& t) : object_(t) { object_.acquire(); }
 ~Guard() { object_.release(); }
};

void foo(const RWDBDatabase& database) {
  Guard guard(sharedConn);
  {
    RWDBStoredProc sp = database::storedProc("myProc", sharedConn);
    sp.execute(sharedConn);
  }
  return;
}

こうしておけば、例外が発生したときGuardのデストラクタがrelease()してくれるのでデッドロックを回避できます。

SQLの直接実行

このように、DBTools.h++はSQLをまったく記述せずにRDBの様々な操作を可能にしてくれます。

しかしながら、特定のRDBだけがサポートするサービスの利用など、場合によってはどうしてもSQLでないと実行できないものもあります。そんなときのために、DBTools.h++はSQLの直接実行を許しています(マニュアルには"お勧めしない"と明記されていますが…)。

以下はRogue Waveのサポートチームが提供してくれた、SQL直接実行のサンプルです。コメントは適宜和訳しました。

/*
** 以下のSQL-SELECT文を実行するプログラム
** (外部結合の入れ子はDBTools.h++では未サポート)
**
**  SELECT t0.NAME, t1.NAME
**  FROM T_JOB t1 RIGHT JOIN
**   (T_EMP t0 INNER JOIN T_MAP t2
**      on t0.ID = t2.EMP_ID)
**   on t1.ID = t2.JOB_ID
*/

#include 
#include 

void errorHandler (const RWDBStatus& aStatus) {
  // エラーメッセージを出力
  if (((int)aStatus.errorCode()) != 0) {
    cout << "Error code:       " << (int) aStatus.errorCode() << endl
           << "Error message     " << aStatus.message() << endl
           << "Is terminal:      " << (aStatus.isTerminal() ? "Yes" : "No") << endl
           << "Vendor error 1:   " << aStatus.vendorError1() << endl
           << "Vendor error 2:   " << aStatus.vendorError2() << endl
           << "Vendor message 1: " << aStatus.vendorMessage1() << endl
           << "Vendor message 2: " << aStatus.vendorMessage2() << endl;
  }
}

int main()  {

  // エラーハンドラをセット
  RWDBManager::setErrorHandler(errorHandler);

  // データベースとの接続
  // (接続パラメータは環境に合わせて適宜変更すること)
  RWDBDatabase dataBase =
    RWDBManager::database("library","server","user","password","");

  // コネクションの生成
  RWDBConnection conn = dataBase.connection();

  // SQL文のトレース
  RWDBTracer& tracer = dataBase.tracer();
  tracer.setOn(RWDBTracer::SQL);
  tracer.stream(cout);

  // 3つのテーブル 'T_EMP', 'T_JOB', 'T_EMP' を作成
  RWDBTable tab1 = dataBase.table("T_EMP");
  RWDBTable tab2 = dataBase.table("T_JOB");
  RWDBTable tab3 = dataBase.table("T_MAP");
  if(!tab1.exists(conn, TRUE)) {
    conn.executeSql("create table T_EMP(ID int, NAME char(10))");
    conn.executeSql("insert into T_EMP values(1, 'bill')");
    conn.executeSql("insert into T_EMP values(2, 'sally')");
    conn.executeSql("insert into T_EMP values(3, 'dave')");
    conn.executeSql("insert into T_EMP values(4, 'ted')");
    conn.executeSql("insert into T_EMP values(5, 'george')");
  }

  if(!tab2.exists(conn, TRUE)) {
    conn.executeSql("create table T_JOB(ID int, NAME char(10))");
    conn.executeSql("insert into T_JOB values(1, 'porter')");
    conn.executeSql("insert into T_JOB values(2, 'smelter')");
    conn.executeSql("insert into T_JOB values(3, 'fisher')");
    conn.executeSql("insert into T_JOB values(4, 'bell hop')");
    conn.executeSql("insert into T_JOB values(5, 'cook')");
  }

  if(!tab3.exists(conn, TRUE)) {
    conn.executeSql("create table T_MAP(EMP_ID int, JOB_ID int)");
    conn.executeSql("insert into T_MAP values(1, 1)");
    conn.executeSql("insert into T_MAP values(2, 2)");
    conn.executeSql("insert into T_MAP values(3, 3)");
    conn.executeSql("insert into T_MAP values(4, 4)");
    conn.executeSql("insert into T_MAP values(5, 5)");
    conn.executeSql("insert into T_MAP values(1, 6)");  // T_MAP.EMP_ID は必ず
    conn.executeSql("insert into T_MAP values(2, 7)");  // T_EMP.ID に存在するが、
    conn.executeSql("insert into T_MAP values(3, 8)");  // T_MAP.JOB_ID は
    conn.executeSql("insert into T_MAP values(4, 9)");  // T_JOB.ID になくてもかまわない
    conn.executeSql("insert into T_MAP values(5, 10)");

  }
  //  後に続くcleanupのためにselector/readerを解放すべく、{}で囲んだ
  {
    RWDBSelector select = dataBase.selector();
    select << tab1["NAME"] << tab2["NAME"];

    // 冒頭のコメントに書かれたSQLと等価な条件式を作る
    RWDBPhraseBook phrase = dataBase.phraseBook();
    RWDBExprFormDefinition on("on %0 %1 %2");
    RWDBExprFormDefinition RJOneArg = ("%0 RIGHT JOIN ");
    RWDBExprFormDefinition IJTwoArg = ("%0 INNER JOIN %1 ");
    RWDBExpr eq("=", FALSE);
    RWCString cs =  RJOneArg(tab2).asString(phrase) + "("
            + IJTwoArg(tab1,tab3).asString(phrase)
            + on(tab1["ID"], eq,tab3["EMP_ID"]).asString(phrase) + ") "
            + on(tab2["ID"], eq,tab3["JOB_ID"]).asString(phrase);

    select.from(cs);

    //  RDBに送られるSQLを出力
    cout << select.asString() << endl;
    // SELECT 実行!
    RWDBResult restab = select.execute();

    // 結果を出力
    RWDBReader rdr = restab.table().reader();

    RWDBValue in1;
    RWDBValue in2;
    while(rdr())
    {
      rdr >> in1 >> in2;
      cout << in1.asString() << "\t" << in2.asString() << endl;
    }

  }
  // テーブルを削除
  tab1.drop();
  tab2.drop();
  tab3.drop();
  return 0;
}

DBTools.h++ vs Oracle-OCI/ODBC

TABLE1
フィールド名	型
ID	Integer
Name	String
Percent	Float

上のようなテーブルを読み出すコードをDBTools.h++ と Oracle-OCI,そしてODBCで書かれたコードを示します。DBTools.h++がどれだけ簡単でパワpフルかがわかります。

/* * DBTools.h++ による * 'SELECT * FROM TABLE1' */

#include 
#include 

using namespace std;

int       anInt;
RWCString aString;
float     aFloat;

void main () {
  // データベースをオープン
  RWDBDatabase aDB =
    RWDBManager::database("ODBC", "Q+E_paradox", "", "", "c:\\paradat");
  // テーブルを取得
  RWDBTable aTable = aDB.table("TABLE1");
  // selectorを取得
  RWDBSelector aSelector = aDB.selector();
  // SELECT * FROM
  aSelector << aTable;
  // readerを取得
  RWDBReader aReader = aSelector.reader();
  // 全レコードを出力
  while (aReader()) {
    aReader >> anInt >> aString >> aFloat;
    cout << anInt << '\t' << aString << '\t' << aFloat << endl;
  }
}

/* Oracle OCI による
 * 'SELECT * FROM TABLE1'
 */
#include 
#include 
#include 
#include 
#include 
#include 
#include 

/* カーソル */

struct cda_def cursorStruct;
struct cda_def *cursor = &cursorStruct;

#define ASTRING_LEN 31

int   anInt;
char  aString[ASTRING_LEN];
float aFloat;

char *selectString = "SELECT * FROM TABLE1";

Lda_Def lda;
text hda[256];

int getOff() {
  ologof(&lda);
  return -1;
}

int main(int argc, char **argv) {
  int ret;
  char *uid = "SCOTT/TIGER";

  /* Oracle にログイン */
  if (orlon(&lda, hda, (text *) uid, -1, 0, -1, -1))
    return getOff();

  /* カーソルオープン */
  if (oopen(cursor, &lda, (text *) 0, -1, -1, (text *) 0, -1))
    return getOff();

  /* SQLを実行 */
  if (osql3(cursor, (text *) selectString, -1))
    return getOff();

  /* 出力バッファにバインド */
  if (odefin(cursor, 1, (ub1 *) &anInt, sizeof(int), OCI_EINT,
             -1, (sb2 *) 0, (text *) 0, -1, -1, (ub2 *) 0, (ub2 *) 0)
      || odefin(cursor, 2, (ub1 *) aString, ASTRING_LEN, OCI_ESTR,
             -1, (sb2 *) 0, (text *) 0, -1, -1, (ub2 *) 0, (ub2 *) 0)
      || odefin(cursor, 3,(ub1 *) &aFloat, sizeof(float), OCI_EFLT,
             -1, (sb2 *) 0, (text *) 0, -1, -1, (ub2 *) 0, (ub2 *) 0))
    return getOff();

  if (oexec(cursor))
    return getOff();

  /* カーソルを移動しながら出力 */
  while (!ofetch(cursor))
    cout << anInt << '\t' << aString << '\t' << aFloat << endl;

  ologof(&lda);
  return 0;
}

/*
 * ODBC による
 * 'SELECT * FROM TABLE1'
 */
#include 
#include 
#include 
#include 
#include 
#include 

#define STRING_LEN 30

HENV    henv;
HDBC    hdbc;
HSTMT   hstmt;
RETCODE retcode;

int   anInt;
UCHAR aString[STRING_LEN];
float aFloat;
SDWORD cbInt, cbString, cbFloat;

void main() {
  /* 環境ハンドルを取得 */
  retcode = SQLAllocEnv(&henv);

  if (retcode != SQL_SUCCESS)
     return; /* Error */

  /* 接続ハンドルを取得 */
  retcode = SQLAllocConnect(henv, &hdbc);

  if (retcode != SQL_SUCCESS)
    return; /* Error */

  /* ログイン・タイムアウトを5秒に設定 */
  SQLSetConnectOption(hdbc, SQL_LOGIN_TIMEOUT, 5);
  /* データソースに接続 */
  retcode = SQLConnect(hdbc, "Q+E_paradox", SQL_NTS, "", SQL_NTS, "", SQL_NTS);

  if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
    return; /* Error */

  /* ステートメントハンドルを取得 */
  retcode = SQLAllocStmt(hdbc, &hstmt);
  /* SQL文の実行 */
  retcode = SQLExecDirect(hstmt, "SELECT * FROM TABLE1", SQL_NTS);

  if (retcode == SQL_SUCCESS) {
    while (TRUE) {
      /* フェッチ */
      retcode = SQLFetch(hstmt);

      if (retcode == SQL_ERROR)
        return; /* Error condition */

      if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) {
        /* レコードの出力 */
        SQLGetData(hstmt, 1, SQL_C_DEFAULT, &anInt, 0, &cbInt);
        SQLGetData(hstmt, 2, SQL_C_CHAR, aString, STRING_LEN, &cbString);
        SQLGetData(hstmt, 3, SQL_C_FLOAT, &aFloat, 0, &cbFloat);
        cout << anInt << '\t' << aString << '\t' << aFloat << endl;
      }
      else
        break;
    }
  }

  SQLFreeStmt(hstmt, SQL_DROP);
  SQLDisconnect(hdbc);
  SQLFreeConnect(hdbc);
  SQLFreeEnv(henv);
}

7つの電話番号簿

cpptechdoc — Thu, 06 Apr 2006 05:56:06 +0000

電話番号簿を作る…

僕のSTL本"Standard Template Library プログラミング"では、STLコンテナのサンプルとして、簡単な電話番号簿を紹介しています。この本の中ではひとつのアプリケーション(電話番号簿)を、STLが提供する様々なコンテナを使って実装してみました。

このアーティクルでは趣向を変えて、電話番号簿アプリケーションをSTL,MFCコレクション,そしてTools.h++を使った実装を試み、それぞれの違いをご覧にいれましょう。

電話番号簿は"電話番号(Key)と名前(Value)の対応表(Map)"です。電話番号簿の機能は:

電話番号と名前の組を登録する
電話番号から名前を検索する
電話番号(と名前の組)を削除する
すべての電話番号(と名前の組)を削除する
登録された電話番号と名前の組をファイルに書き込む/読み出す

の5つです。

Standard C++ : STL

ANSI/ISO standard C++(標準C++)のライブラリの一部として組み入れられたSTL。STLは数多くのライブラリの中でも最もポータビリティに優れたライブラリといえるでしょう。何といっても標準ですからね。

map

STLが提供するmapは、電話番号簿を実装するのに最適のコンテナで、2つのデータの1対1の対応表を実現します。

mapは電話番号簿の実装に必要な機能のほとんどを満足しているのですが、ただひとつ、ファイルに対する書き込み/読み込み部分はプログラマが用意しなくてはなりません。

mapに限らずSTLは基本的な最小限の機能をきっちりとサポートするというのがコンセプトであり、ファイルに対する入出力については"道具は用意してやるから、必要ならばあんたが作んな"というスタンスに立っているのです。

/*
 * phonebook.cpp
 *   standard C++ STL
 *   map を使った簡単な電話番号簿
 */

#include    // cin, cout
#include     // ifstream, ofstream
#include      // string
#include         // map
#include    // istream_iterator, ostream_iterator
#include   // copy

using namespace std;

// 名前(string)をKey, 電話番号(string)をValueとする辞書
typedef map    book_type;

/* namespace std { ... } の必要はないのだが、VC++ではこうしないと
 * compile errorとなる。 */
namespace std {

  // レコード(名前と電話番号の組)を出力する
  ostream& operator<<(ostream& strm, const book_type::value_type& v) {
    return strm << v.first
           << " : "
           << v.second;
  }

  // レコード(名前と電話番号の組)を入力する
  istream& operator>>(istream& strm, book_type::value_type& v) {
    // 名前と電話番号の間にある':'を抜くためにdummyを用意した
    char dummy;
    return strm >> const_cast(v.first) // [1]
                >> dummy
                >> v.second;
  }

}

// プロンプト
char prompt() {
  string command;
  cout << "add/delete/find/list/clear/quit [a,d,f,l,c,q] ?" << flush;
  cin >> command;
  return command[0];
}

int main() {

  book_type book;

  // 電話番号簿をファイルから読み出す
  cout << "loading file..." << endl;
  ifstream in("phonebook.txt");
  if ( in.is_open() ) {
    copy(istream_iterator(in), // [2]
         istream_iterator(),
         inserter(book, book.begin()));
    in.close();
  }

  bool quit = false;
  do {
    string name;
    string phone;
    switch ( prompt() ) {
    // 追加
    case 'a' : case 'A' : {
      cout << "name:" << flush;
      cin >> name;
      // 登録されていないことを確認する
      if ( book.find(name) != book.end() ) {
        cout << "already exists." << endl;
      } else {
        cout << "phone:" << flush;
        cin >> phone;
        // レコードを追加する
        book[name] = phone;
      }
      break;
    }
    // 削除
    case 'd' : case 'D' : {
      cout << "name:" << flush;
      cin >> name;
      // 登録されていればそれを削除する
      if ( book.find(name) == book.end() ) {
        cout << "not found." << endl;
      } else {
        book.erase(name); // [3]
      }
      break;
    }
    // 検索
    case 'f' : case 'F' : {
      cout << "name:" << flush;
      cin >> name;
      // 登録されていればそのレコードを出力する
      book_type::iterator i = book.find(name);
      if ( i == book.end() ) {
        cout << "not found." << endl;
      } else {
        cout << *i << endl;
      }
      break;
    }
    // リスト
    case 'l' : case 'L' : {
      cout << book.size() << "entries:" << endl;
      // 全レコードを出力する
      copy(book.begin(),
           book.end(),
           ostream_iterator(cout,"¥n"));
      break;
    }
    // クリア
    case 'c' : case 'C' : {
      book.clear();
      break;
    }
    // 終了
    case 'q' : case 'Q' : {
      quit = true;
      break;
    }
    default :
      cout << '?' << endl;
    }
  } while ( !quit );

  // 電話番号簿をファイルに書き込む
  cout << "saving file..." << endl;
  ofstream out("phonebook.txt");
  if ( out.is_open() ) {
    copy(book.begin(),
         book.end(),
         ostream_iterator(out,"¥n"));
    out.close();
  }

  return 0;
}

1:

map::value_type は pair<const Key, T>であるため、ストリームから読み出したKeyを代入できません。そこでconst_castによってconst Key& をKey&にキャストしています。

2:

アルゴリズム copy と istream_iterator, insert_iterator を使ってストリームから読み出し、bookに登録しています。

3:

直前のbook.find(name)で得られたiteratorを流用する、すなわち:

book_type::iterator it = book.find(name);
if ( it == book.end() ) {
  cout << "not found." << endl;
} else {
  book.erase(it);
}

としたほうがbetterでしょう。このままでは検索が2回行われることになりますから。

Microsoft : MFC

Microsoft Visual C++(VC++)はWindows環境下でのC++アプリケーション開発環境として不動の地位を保っています。VC++がこれだけポピュラーな開発環境となった要因としてMFC(Microsoft Foundation Classes)の存在は外せません。MFCがなかったらVC++がこれほどまでに多くのプログラマに支持されることはなかったでしょう。

MFCの提供するコレクション(コンテナ)には様々なものがありますが、電話番号簿に適したクラスといえばCMapStringToStringおよびCMapでしょうか。

CMapStringToString

CMapStringToStringは同じくMFCが提供する文字列クラスCStringをKey/Valueとする対応表です。MFCはその昔、Windows3.xの頃から使われていました。当時のVC++(v1.x)はまだtemplateをサポートしていなかったため、template を使わないコンテナがいくつか提供されており、現在もMFCﾉ中に生き残っています。CMapStringToStringはその旧き善き(?)コンテナクラスのひとつです。

CMapStringToStringはハッシュ表で実装されています。ですから検索は非常に高速ですが、コンテナの内容を順次取り出したときKeyの大小関係とは全く関係の無い順序となっています。

/*
 * phonebook.cpp
 *   Microsoft MFC
 *   CMapStringToString を使った簡単な電話番号簿
 */

#include      // CMapStringToString, CFile, CArchive, CString
#include   // cin, cout

using namespace std;

// プロンプト
char prompt() {
  char command[256];
  cout << "add/delete/find/list/clear/quit [a,d,f,l,c,q] ?" << flush;
  cin >> command;
  return command[0];
}

int main() {

  CMapStringToString book;

  // 電話番号簿をファイルから読み出す
  cout << "loading file..." << endl;
  {
    CFile in;
    if ( in.Open("phonebook.dat",CFile::modeRead) ) {
      CArchive ar(&in,CArchive::load);
      book.Serialize(ar);
    }
  }

  bool quit = false;
  do {
    char name[64];
    char phone[64];
    CString key;
    CString value;
    switch ( prompt() ) {
    // 追加
    case 'a' : case 'A' : {
      cout << "name:" << flush;
      cin >> name;
      // 登録されていないことを確認する
      if ( book.Lookup(name,value) ) { // [1]
        cout << "already exists." << endl;
      } else {
        cout <> phone;
        // レコードを追加する
        book.SetAt(name,phone);
      }
      break;
    }
    // 削除
    case 'd' : case 'D' : {
      cout << "name:" << flush;
      cin >> name;
      // 登録されていればそれを削除する
      if ( !book.Lookup(name,value) ) {
        cout << "not found." << endl;
      } else {
        book.RemoveKey(name);
      }
      break;
    }
    // 検索
    case 'f' : case 'F' : {
      cout << "name:" << flush;
      cin >> name;
      // 登録されていればそのレコードを出力する
      if ( !book.Lookup(name,value) ) {
        cout << "not found." << endl;
      } else {
        cout << name
             (value)// [2]
             << endl;
      }
      break;
    }
    // リスト
    case 'l' : case 'L' : {
      cout << book.GetCount() << "entries:" << endl;
      // 全レコードを出力する
      POSITION pos = book.GetStartPosition(); // [3]
      while ( pos ) {
        book.GetNextAssoc(pos,key,value);
        cout << static_cast(key)
             << " : "
             << static_cast(value)
             << endl;
      }
      break;
    }
    // クリア
    case 'c' : case 'C' : {
      book.RemoveAll();
      break;
    }
    // 終了
    case 'q' : case 'Q' : {
      quit = true;
      break;
    }
    default :
      cout << '?' &ltl&ltl endl;
    }
  } while ( !quit );

  // 電話番号簿をファイルに書き込む
  cout << "saving file..." >> endl;
  {
    CFile out;
    if ( out.Open("phonebook.dat",CFile::modeWrite|CFile::modeCreate) ) {
      CArchive ar(&out,CArchive::store);
      book.Serialize(ar);
    }
  }

  return 0;
}

1:

CMapStringToString::Lookup(LPCTSTR k, CString& v): 検索を行ないます。keyを探し、見つかったら対応するvalueをvにセットしてくれます。

2:

CStringはストリームに対して<<できません。const char*にキャストします。

3:

MFCコレクションの要素を順に取り出すには、このような奇怪なやり方になるんですよね。

POSITION pos = book.GetStartPosition(); // 先頭位置を取得する
while ( pos ) {
  book.GetNextAssoc(pos,key,value); // keyとvalueを手に入れ、posをひとつ進める
  ...
}

CMap

VC++がtemplateをサポートするようになって、MFCにもtemplateを用いたコンテナが提供されるようになりました。CMapはtemplateによるコンテナのひとつです。

CMapもCMapStringToStringと同様、ハッシュ表による対応表です。ハッシュ表を実現するにはデータからハッシュ値を返すハッシュ関数、そして2つのデータが同じであるかを判断する関数が必要ですが、MFCではプログラマがこれらヘルパ関数を定義することで与えます。電話番号簿の例ではハッシュ関数ヘルパを明示的に定義してはいません。これはKeyであるCStringのハッシュ関数はあらかじめMFCが用意してくれているからです。

このようにあらかじめ与えておいたひとつのハッシュ関数/比較関数をすべてのCMapから呼び出す構造であり、用途に応じてハッシュ/比較関数をとりかえることができません。たとえば

struct person {
  CString name;
  CString id;
  ...
}

があったとき、nameで検索するCMapとidで検索するCMapをひとつのアプリケーションの中で実装するのが非常に困難です(無理をすればできないこともないのですが…)。

/*
 * phonebook.cpp
 *   Microsoft MFC
 *   CMap を使った簡単な電話番号簿
 */

#include       // CFile, CArchive, CString
#include  // CMap
#include    // cin, cout

using namespace std;

// プロンプト: 省略

int main() {

  CMap book;

  // 電話番号簿をファイルから読み出す
  cout << "loading file..." << endl;
  {
    CFile in;
    if ( in.Open("phonebook.dat",CFile::modeRead) ) {
      CArchive ar(&in,CArchive::load);
      book.Serialize(ar);
    }
  }

  bool quit = false;
  do {
    char name[64];
    char phone[64];
    CString key;
    CString value;
    switch ( prompt() ) {
    // 追加
    case 'a' : case 'A' : {
      cout << "name:" << flush;
      cin >> name;
      // 登録されていないことを確認する
      if ( book.Lookup(name,value) ) {
        cout << "already exists." << endl;
      } else {
        cout << "phone:" << flush;
        cin >> phone;
        // レコードを追加する
        book.SetAt(name,phone);
      }
      break;
    }
    // 削除
    case 'd' : case 'D' : {
      cout << "name:" << flush;
      cin >> name;
      // 登録されていればそれを削除する
      if ( !book.Lookup(name,value) ) {
        cout << "not found." << endl;
      } else {
        book.RemoveKey(name);
      }
      break;
    }
    // 検索
    case 'f' : case 'F' : {
      cout << "name:" << flush;
      cin >> name;
      // 登録されていればそのレコードを出力する
      if ( !book.Lookup(name,value) ) {
        cout << "not found." << endl;
      } else {
        cout << name
             << " : "

             << static_cast(value)
             << endl;
      }
      break;
    }
    // リスト
    case 'l' : case 'L' : {
      cout << book.GetCount() << "entries:" << endl;
      // 全レコードを出力する
      POSITION pos = book.GetStartPosition();
      while ( pos ) {
        book.GetNextAssoc(pos,key,value);
        cout << static_cast(key)
             << " : "

             << static_cast(value)
             << endl;
      }
      break;
    }
    // クリア
    case 'c' : case 'C' : {
      book.RemoveAll();
      break;
    }
    // 終了
    case 'q' : case 'Q' : {
      quit = true;
      break;
    }
    default :
      cout << '?' << endl;
    }
  } while ( !quit );

  // 電話番号簿をファイルに書き込む
  cout << "saving file..." << endl;
  {
    CFile out;
    if ( out.Open("phonebook.dat",CFile::modeWrite|CFile::modeCreate) ) {
      CArchive ar(&out,CArchive::store);
      book.Serialize(ar);
    }
  }

  return 0;
}

Rogue Wave : Tools.h++

Rogue Wave Software社のクラスライブラリTools.h++は様々なOS/コンパイラに対応した、優れたライブラリです。

STLが提供するコンテナは以下の7種:

vector ------ 可変長配列
list -------- 双方向リスト
deque ------- 両端キュー
set --------- 重複を許さない集合
multiset ---- 重複を許す集合
map --------- 重複を許さない辞書
multimap ---- 重複を許す辞書

MFCでは

CArray ---- 可変長配列
CList ----- 双方向リスト
CMap ------ 重複を許さない辞書

の、たったの3種です。

これに対しTools.h++は、

RWBitVec ---------------------------- ビットベクタ
RWBTreeOnDisk ----------------------- ディスク上のB木
    RWBag --------------------------- バッグ
    RWBinaryTree -------------------- 2進木
    RWBTree ------------------------- B木
      RWBTreeDictionary ------------- B木による辞書
      RWDlistCollectables ----------- 双方向リスト
      RWOrdered --------------------- 可変長配列
        RWSortedVector -------------- ソートされた配列
      RWSlistCollectables ----------- 単方向リスト
        RWSlistCollectablesQueue ---- キュー
        RWSlistCollectablesStack ---- スタック
    RWHashTable --------------------- ハッシュ表
      RWSet ------------------------- セット
        RWHashDictionary ------------ 辞書
          RWIdentityDictionary ------ 同一性辞書
        RWIdentitySet --------------- 同一性セット

RWGBitVec(size) --------------------- ビット配列
RWGDlist(type) ---------------------- 双方向リスト
RWGOrderedVector(val) --------------- 可変長配列
RWGQueue(type) ---------------------- キュー
RWGSlist(type) ---------------------- 単方向リスト
RWGSortedVector(val) ---------------- ソートされた配列
RWGStack(type) ---------------------- スタック
RWGVector(val) ---------------------- 配列

RWTBitVec --------------------- ビットベクタ
RWTIsvDlist ---------------------- 挿入的双方向リスト
RWTIsvSlist ---------------------- 挿入的単方向リスト
RWTPtrDlist ---------------------- 双方向リスト
RWTPtrHashTable ------------------ ハッシュ表
  RWTPtrHashSet ------------------ セット
RWTPtrHashDictionary ----------- 辞書
RWTPtrOrderedVector -------------- 配列
RWTPtrSlist ---------------------- 単方向リスト
RWTPtrSortedVector --------------- ソートされた配列
RWTPtrVector --------------------- 配列
RWTQueue ----------------------- キュー
RWTStack ----------------------- スタック
RWTValDlist ---------------------- 双方向リスト
RWTValHashTable ------------------ ハッシュ表
  RWTValHashSet ------------------ セット
RWTValHashDictionary ----------- 辞書
RWTValOrderedVector -------------- 配列
  RWTValSortedVector ------------- ソートされた配列
RWTValSlist ---------------------- 単方向リスト
RWTValVector --------------------- 配列

これだけのコンテナを用意してくれています。

RWBTreeDictionay

RWBTreeDictionaryはその名の通り、B-treeで実装された対応表です。KeyとValueはどちらもRWCollectableの派生クラスでなくてはなりません。Tools.h++の文字列クラスRWCollectableStringはRWCollectableの派生クラスであるため、RWBTreeDictionaryの要素となれます。

/*
 * phonebook.cpp
 *   Rogue Wave Tools.h++
 *   RWBTreeDictionary を使った簡単な電話番号簿
 */

#include      // cin, cout
#include  // RWBTreeDictionary
#include  // RWCollectableString

using namespace std;

void print_record(RWCollectable* key, RWCollectable* value, void* s) {
  ostream& strm = *static_cast(s);
  strm << *static_cast(key)
       << " : "

       << *static_cast(value)
       << endl;
}

// プロンプト
char prompt() {
  RWCString command;
  cout << "add/delete/find/list/clear/quit [a,d,f,l,c,q] ?" << flush;
  cin >> command;
  return command[0U];
}

int main() {

  RWBTreeDictionary book;

  // 電話番号簿をファイルから読み出す
  cout << "loading file..." << endl;
  {
    RWFile in("phonebook.dat","rb");
    if ( in.isValid() ) {
      in >> book;
    }
  }

  bool quit = false;
  do {
    RWCollectableString name;
    RWCollectableString phone;
    RWCollectable* key;
    RWCollectable* value;
    switch ( prompt() ) {
    // 追加
    case 'a' : case 'A' : {
      cout << "name:" << flush;
      cin >> name;
      // 登録されていないことを確認する
      if ( book.contains(&name) ) {
        cout << "already exists." << endl;
      } else {
        cout << "phone:" << flush;
        cin >> phone;
        // レコードを追加する
        book.insertKeyAndValue(new RWCollectableString(name), // [1]

                               new RWCollectableString(phone));
      }
      break;
    }
    // 削除
    case 'd' : case 'D' : {
      cout << "name:" << flush;
      cin >> name;
      // 登録されていればそれを削除する
      key = book.removeKeyAndValue(&name,value);
      if ( !key ) {
        cout << "not found." << endl;
      } else {
        delete key; // [2]

        delete value;
      }
      break;
    }
    // 検索
    case 'f' : case 'F' : {
      cout << "name:" << flush;
      cin >> name;
      // 登録されていればそのレコードを出力する
      value = book.findValue(&name);
      if ( !value ) {
        cout << "not found." << endl;
      } else {
        print_record(&name,value,&cout);
      }
      break;
    }
    // リスト
    case 'l' : case 'L' : {
      cout << book.entries() << "entries:" << endl;
      // 全レコードを出力する
      book.applyToKeyAndValue(&print_record,&cout); // [3]

      break;
    }
    // クリア
    case 'c' : case 'C' : {
      book.clearAndDestroy(); // [4]
      break;
    }
    // 終了
    case 'q' : case 'Q' : {
      quit = true;
      break;
    }
    default :
      cout << '?' << endl;
    }
  } while ( !quit );

  // 電話番号簿をファイルに書き込む
  cout << "saving file..." << endl;
  {
    RWFile out("phonebook.dat","wb");
    if ( out.isValid() ) {
      out << book;
    }
  }

  // [5]

  return 0;
}

1:: RWBTreeDictionaryは参照ベースコンテナ、すなわち要素のポインタをコンテナ内に格納します。ですから、operator new() によってインスタンスをヒープから生成しなければなりません。
2:: メモリ･リークを起こさぬよう、確実にdeleteしましょう。
3:: 残念なことにRWBTreeDictionaryはイテレータによる反復をサポートしていません。メソッドapplyToKeyAndValue()はコンテナ内の全要素に対し指定した関数を適用します。
4:: メソッドclearAndDestroy()はコンテナ内の全要素をdeleteします。
5:: おっと、最後に book.clearAndDestroy() するのを忘れてますね^^;

RWHashDictionary

RWHashDictionaryはハッシュ表による辞書です。要素の基底クラスRWCollectableに定義されたハッシュ関数/比較関数を派生クラスで再定義します。RWCollectableStringはハッシュ関数/比較関数があらかじめ再定義されているので、以下のサンプルのようにそのまま用いることができます。MFCのCMapと同じく、ハッシュ関数/比較関数を任意に設定できないのが欠点です。

/*
 * phonebook.cpp
 *   Rogue Wave Tools.h++
 *   RWHashDictionary を使った簡単な電話番号簿
 */

#include       // cin, cout
#include  // RWHashDictionary
#include   // RWCollectableString

using namespace std;

// プロンプト: 省略

int main() {

  RWHashDictionary book;

  // 電話番号簿をファイルから読み出す
  cout << "loading file..." << endl;
  {
    RWFile in("phonebook.dat","rb");
    if ( in.isValid() ) {
      in >> book;
    }
  }

  bool quit = false;
  do {
    RWCollectableString name;
    RWCollectableString phone;
    RWCollectable* key;
    RWCollectable* value;
    switch ( prompt() ) {
    // 追加
    case 'a' : case 'A' : {
      cout << "name:" << flush;
      cin >> name;
      // 登録されていないことを確認する
      if ( book.contains(&name) ) {
        cout << "already exists." << endl;
      } else {
        cout << "phone:" << flush;
        cin >> phone;
        // レコードを追加する
        book.insertKeyAndValue(new RWCollectableString(name),
                               new RWCollectableString(phone));
      }
      break;
    }
    // 削除
    case 'd' : case 'D' : {
      cout << "name:" << flush;
      cin >> name;
      // 登録されていればそれを削除する
      key = book.removeKeyAndValue(&name,value);
      if ( !key ) {
        cout << "not found." << endl;
      } else {
        delete key;
        delete value;
      }
      break;
    }
    // 検索
    case 'f' : case 'F' : {
      cout << "name:" << flush;
      cin >> name;
      // 登録されていればそのレコードを出力する
      value = book.findValue(&name);
      if ( !value ) {
        cout << "not found." << endl;
      } else {
        cout << name
             << " : "

             << *static_cast(value)
             << endl;
      }
      break;
    }
    // リスト
    case 'l' : case 'L' : {
      cout << book.entries() << "entries:" << endl;
      // 全レコードを出力する
      RWHashDictionaryIterator it(book);
      while ( it() ) {
        cout << *static_cast(it.key())
             << " : "

             << *static_cast(it.value())
             << endl;
      }
      break;
    }
    // クリア
    case 'c' : case 'C' : {
      book.clearAndDestroy();
      break;
    }
    // 終了
    case 'q' : case 'Q' : {
      quit = true;
      break;
    }
    default :
      cout << '?' << endl;
    }
  } while ( !quit );

  // 電話番号簿をファイルに書き込む
  cout << "saving file..." << endl;
  {
    RWFile out("phonebook.dat","wb");
    if ( out.isValid() ) {
      out << book;
    }
  }

  return 0;
}

RWTValMap

Tools.h++のtemplate版辞書がRWTValMapです。RWTValMapはSTLのmapと同様、要素の大小関係に基づいた2進木で実装されています。大小関係を判断する関数オブジェクトを第3template引数に与える構造であるため、比較関数を取り替えることで任意のKey照合が使えます。

/*
 * phonebook.cpp
 *   Rogue Wave Tools.h++
 *   RWTValMap を使った簡単な電話番号簿
 */

#include       // cin, cout
#include     // less
#include     // RWTValMap
#include   // RWCString

using namespace std;

// プロンプト: 省略

int main() {

  RWTValMap< RWCString,RWCString,less > book;

  // 電話番号簿をファイルから読み出す
  cout << "loading file..." << endl;
  {
    RWFile in("phonebook.dat","rb");
    if ( in.isValid() ) {
      in >> book;
    }
  }

  bool quit = false;
  do {
    RWCString name;
    RWCString phone;
    switch ( prompt() ) {
    // 追加
    case 'a' : case 'A' : {
      cout << "name:" << flush;
      cin >> name;
      // 登録されていないことを確認する
      if ( book.contains(name) ) {
        cout << "already exists." << endl;
      } else {
        cout << "phone:" << flush;
        cin >> phone;
        // レコードを追加する
        book[name] = phone;
      }
      break;
    }
    // 削除
    case 'd' : case 'D' : {
      cout << "name:" << flush;
      cin >> name;
      // 登録されていればそれを削除する
      if ( !book.remove(name) ) {
        cout << "not found." << endl;
      }
      break;
    }
    // 検索
    case 'f' : case 'F' : {
      cout << "name:" << flush;
      cin >> name;
      // 登録されていればそのレコードを出力する
      if ( !book.findValue(name,phone) ) {
        cout << "not found." << endl;
      } else {
        cout << name << " : " << phone << endl;
      }
      break;
    }
    // リスト
    case 'l' : case 'L' : {
      cout << book.entries() << "entries:" << endl;
      // 全レコードを出力する
      RWTValMapIterator< RWCString,RWCString,less > it(book);
      while ( it() ) {
        cout << it.key() << " : " << it.value() << endl;
      }
      break;
    }
    // クリア
    case 'c' : case 'C' : {
      book.clear();
      break;
    }
    // 終了
    case 'q' : case 'Q' : {
      quit = true;
      break;
    }
    default :
      cout << '?' << endl;
    }
  } while ( !quit );

  // 電話番号簿をファイルに書き込む
  cout << "saving file..." << endl;
  {
    RWFile out("phonebook.dat","wb");
    if ( out.isValid() ) {
      out << book;
    }
  }

  return 0;
}

RWTValHashMap

RWTValHashMapはハッシュ表によるtemplate版辞書です。第3/第4template引数にハッシュ関数/比較関数を与えるので、任意のKey照合が使えます。

/*
 * phonebook.cpp
 *   Rogue Wave Tools.h++
 *   RWTValHashMap を使った簡単な電話番号簿
 */

#include      // cin, cout
#include    // unary_function, equal_to
#include   // RWTValHashMap
#include  // RWCString

using namespace std;

// プロンプト: 省略

struct hash_str : std::unary_function {
  unsigned long operator()(const RWCString& x) const {
    return x.hash();
  }
};

int main() {

  RWTValHashMap< RWCString,RWCString,hash_str,equal_to > book; // [1]

  // 電話番号簿をファイルから読み出す
  cout << "loading file..." << endl;
  {
    RWFile in("phonebook.dat","rb");
    if ( in.isValid() ) {
      in >> book;
    }
  }

  bool quit = false;
  do {
    RWCString name;
    RWCString phone;
    switch ( prompt() ) {
    // 追加
    case 'a' : case 'A' : {
      cout << "name:" << flush;
      cin >> name;
      // 登録されていないことを確認する
      if ( book.contains(name) ) {
        cout << "already exists." << endl;
      } else {
        cout << "phone:" << flush;
        cin >> phone;
        // レコードを追加する
        book[name] = phone;
      }
      break;
    }
    // 削除
    case 'd' : case 'D' : {
      cout << "name:" << flush;
      cin >> name;
      // 登録されていればそれを削除する
      if ( !book.remove(name) ) {
        cout << "not found." << endl;
      }
      break;
    }
    // 検索
    case 'f' : case 'F' : {
      cout << "name:" << flush;
      cin >> name;
      // 登録されていればそのレコードを出力する
      if ( !book.findValue(name,phone) ) {
        cout << "not found." << endl;
      } else {
        cout << name << " : " << phone << endl;
      }
      break;
    }
    // リスト
    case 'l' : case 'L' : {
      cout << book.entries() << "entries:" << endl;
      // 全レコードを出力する
      RWTValHashMapIterator< RWCString,RWCString,hash_str,equal_to > it(book);
      while ( it() ) {
        cout << it.key() << " : " << it.value() << endl;
      }
      break;
    }
    // クリア
    case 'c' : case 'C' : {
      book.clear();
      break;
    }
    // 終了
    case 'q' : case 'Q' : {
      quit = true;
      break;
    }
    default :
      cout << '?' << endl;
    }
  } while ( !quit );

  // 電話番号簿をファイルに書き込む
  cout << "saving file..." << endl;
  {
    RWFile out("phonebook.dat","wb");
    if ( out.isValid() ) {
      out << book;
    }
  }

  return 0;
}

1:: RWTValHashMapの第3/4templateにはハッシュ関数と比較関数を与えます。

STLとの親和性

Tools.h++のtemplateコンテナは

STL依存モード
STL独立モード

2種類の実装モードが選択できます。STL依存モードでは、templateコンテナの実装に、可能な限りSTLを使います。たとえばさきほどのRWTValMapの場合、クラス内部にSTLコンテナであるstd::mapのインスタンスを内包し、各メソッドはSTLコンテナに委譲します。

STL依存モードではbegin(),end()などのSTLコンパチなメソッドが公開されるので、STLアルゴリズムにそのまま引き渡すことができます。

このメカニズムによって、通常はインタフェースの簡単なTools.h++コンテナを使い、必要に応じてSTLを利用することができ、STLとの親和性は抜群です。

    // こう書いてもいいわけだ
    RWTValMap< RWCString,RWCString,less > book;
    ...
    // リスト
    case 'l' : case 'L' : {
      cout << book.entries() << "entries:" << endl;
      // 全レコードを出力する
      RWTValMap< RWCString,RWCString,less >::iterator it = book.begin();
      while ( it != it.end() ) {
        cout << it->first << " : " << it->second << endl;
        ++it;
      }
      break;
    }

電話番号簿の7つの実装、あなたはどれがお好みですか?

僕は…そうねぇ、RWTValMapあたりが涼しげで好きですね。

おまけ: Java

Java(JDK 1.2.x)でも書いてみました。ObjectSpace社のライブラリJGL(Generic Collection Library for Java)のcom.objectspace.jgl.HashMap、そしてJDK1.2のサポートするjava.util.Hashtableによる実装です。

JGL3.1 com.objectspace.jgl.HashMap

JGLはSTLのJavaによる迫真の実装ともいえるライブラリです。HashMapに登録された全レコードを出力している部分にご注目ください。JGLのコンテナもSTLと同様、イテレータを返すメソッドbegin()/end()を持っていることがわかるでしょう。

/*
 * phonebook.java
 *   Sun Microsystem Java2
 *   com.objectspace.jgl.HashMap を使った簡単な電話番号簿
 */

import com.objectspace.jgl.*;
import java.io.*;

public class phonebook {

  static BufferedReader cin = new BufferedReader(new InputStreamReader(System.in));
  static PrintStream    cout = System.out;

  static char prompt() {
    String command = "?";
    cout.print("add/delete/find/list/clear/quit [a,d,f,l,c,q] ?");
    cout.flush();
    try {
      command = cin.readLine();
    } catch ( IOException e ) {}
    return command.charAt(0);
  }

  public static void main(String[] arg) {

    HashMap book = null;

    // 電話番号簿をファイルから読み出す
    cout.println("loading file...");
    try {
      FileInputStream in = new FileInputStream("phonebook.dat");
      ObjectInputStream strm = new ObjectInputStream(in);
      book = (HashMap)strm.readObject();
    } catch ( Exception e ) {}

    if ( book == null )
      book = new HashMap();

    try {
    boolean quit = false;
    do {
      String name;
      String phone;
      Object value;
      switch ( prompt() ) {
      // 追加
      case 'a' : case 'A' : {
        cout.print("name:");
        cout.flush();
        name = cin.readLine();
        // 登録されていないことを確認する
        if ( book.get(name) != null ) {
          cout.println("already exists.");
        } else {
          cout.print("phone:");
          phone = cin.readLine();
          // レコードを追加する
          book.add(name,phone);
        }
        break;
      }
      // 削除
      case 'd' : case 'D' : {
        cout.print("name:");
        cout.flush();
        name = cin.readLine();
        // 登録されていればそれを削除する
        if ( book.remove(name) == null ) {
          cout.println("not found.");
        }
        break;
      }
      // 検索
      case 'f' : case 'F' : {
        cout.print("name:");
        cout.flush();
        name = cin.readLine();
        // 登録されていればそのレコードを出力する
        value = book.get(name);
        if ( value == null ) {
          cout.println("not found.");
        } else {
          cout.println(name + " : " + value);
        }
        break;
      }
      // リスト
      case 'l' : case 'L' : {
        cout.println(book.size() + "entries:");
        // 全レコードを出力する
        HashMapIterator it = book.begin();
        while ( !it.equals(book.end()) ) {
          cout.println(it.key() + " : " + it.value());
          it.advance();
        }
        break;
      }
      // クリア
      case 'c' : case 'C' : {
        book.clear();
        break;
      }
      // 終了
      case 'q' : case 'Q' : {
        quit = true;
        break;
      }
      default :
        cout.println("?");
      }
    } while ( !quit );
    } catch ( Exception e ) {
      e.printStackTrace();
    }

    // 電話番号簿をファイルに書き込む
    cout.println("saving file...");
    try {
      FileOutputStream out = new FileOutputStream("phonebook.dat");
      ObjectOutputStream strm = new ObjectOutputStream(out);
      strm.writeObject(book);
    } catch ( Exception e ) {}
  }

}

JDK1.2 java.util.Hashtable

/*
 * phonebook.java
 *   Sun Microsystem Java2
 *   java.util.Hashtable を使った簡単な電話番号簿
 */

import java.util.*;
import java.io.*;

public class phonebook {

  static BufferedReader cin = new BufferedReader(new InputStreamReader(System.in));
  static PrintStream    cout = System.out;

  // プロンプト: 省略

  public static void main(String[] arg) {

    Hashtable book = null;

    // 電話番号簿をファイルから読み出す
    cout.println("loading file...");
    try {
      FileInputStream in = new FileInputStream("phonebook.dat");
      ObjectInputStream strm = new ObjectInputStream(in);
      book = (Hashtable)strm.readObject();
    } catch ( Exception e ) {}

    if ( book == null )
      book = new Hashtable();

    try {
    boolean quit = false;
    do {
      String name;
      String phone;
      Object value;
      switch ( prompt() ) {
      // 追加
      case 'a' : case 'A' : {
        cout.print("name:");
        cout.flush();
        name = cin.readLine();
        // 登録されていないことを確認する
        if ( book.containsKey(name) ) {
          cout.println("already exists.");
        } else {
          cout.print("phone:");
          phone = cin.readLine();
          // レコードを追加する
          book.put(name,phone);
        }
        break;
      }
      // 削除
      case 'd' : case 'D' : {
        cout.print("name:");
        cout.flush();
        name = cin.readLine();
        // 登録されていればそれを削除する
        if ( book.remove(name) == null ) {
          cout.println("not found.");
        }
        break;
      }
      // 検索
      case 'f' : case 'F' : {
        cout.print("name:");
        cout.flush();
        name = cin.readLine();
        // 登録されていればそのレコードを出力する
        value = book.get(name);
        if ( value == null ) {
          cout.println("not found.");
        } else {
          cout.println(name + " : " + value);
        }
        break;
      }
      // リスト
      case 'l' : case 'L' : {
        cout.println(book.size() + "entries:");
        // 全レコードを出力する
        Iterator it = book.entrySet().iterator();
        while ( it.hasNext() ) {
          Map.Entry entry = (Map.Entry)it.next();
          cout.println(entry.getKey() + " : " + entry.getValue());
        }
        break;
      }
      // クリア
      case 'c' : case 'C' : {
        book.clear();
        break;
      }
      // 終了
      case 'q' : case 'Q' : {
        quit = true;
        break;
      }
      default :
        cout.println("?");
      }
    } while ( !quit );
    } catch ( Exception e ) {
      e.printStackTrace();
    }

    // 電話番号簿をファイルに書き込む
    cout.println("saving file...");
    try {
      FileOutputStream out = new FileOutputStream("phonebook.dat");
      ObjectOutputStream strm = new ObjectOutputStream(out);
      strm.writeObject(book);
    } catch ( Exception e ) {}
  }

}

Tools.h++ ProfessionalによるJava/C++相互運用

おまけついでに、Rogue WaveのTools.h++ Professionalが提供する"Java互換シリアライズ"を紹介します。

Javaのシリアライズ機構によってシリアライズされたファイルをC++から読み書きしてしまうという、なんともマジカルな機能です。これによってJava/C++双方からアクセスできる共通のオブジェクトファイルが実現します。

以下のC++コードで作られるデータファイル"phonebook.dat"はJavaストリーム互換であり、Java/C++双方からアクセスできます。

/*
 * phonebook.cpp
 *   Rogue Wave Tools.h++ Professinal
 *   RWTValHashMap を使った簡単な電話番号簿
 *   java:ObjectStream 互換
 */

#include       // cin, cout
#include        // ifstream, ofstream
#include    // unary_function, equal_to
#include   // RWTValHashMap
#include  // RWCString
#include  // Java/C++ mappings

using namespace std;

// プロンプト: 省略

struct hash_str : std::unary_function {
  unsigned long operator()(const RWCString& x) const {
    return x.hash();
  }
};

int main() {

  typedef RWTValHashMap< RWCString,RWCString,hash_str,std::equal_to > book_type;
  book_type* book;

  // 電話番号簿をファイルから読み出す
  cout << "loading file..." << endl;
  {
    ifstream in("phonebook.dat",ios_base::binary | ios_base::in);
    if ( in.is_open() ) {
      // java.io.ObjectInputStream 互換の入力ストリーム
      RWJObjectInputStream strm(in);
      // RWTValHashMapをjava.util.Hashtableへマップする
      RWJDTemplateToolsMap >

        ::registerHashtableToRWTValHashMap(strm);
      strm >> book;
    } else {
      book = new book_type;
    }
  }

  // book.function() を book->function() に置き換えるだけなので、さっくり省略
  ...

  // 電話番号簿をファイルに書き込む
  cout << "saving file..." << endl;
  {
    ofstream out("phonebook.dat",ios_base::binary | ios_base::out | ios_base::trunc);
    if ( out.is_open() ) {
      // java.io.ObjectOutputStream 互換の出力ストリーム
      RWJObjectOutputStream strm(out);
      // RWTValHashMapをjava.util.Hashtableへマップする
      RWJDTemplateToolsMap >

        ::registerHashtableToRWTValHashMap(strm);
      strm << book;
    }
  }

  delete book;

  return 0;
}

Xerces-CにICUを使わせるには

cpptechdoc — Thu, 06 Apr 2006 05:56:06 +0000

使えない文字コード

Apache Xerces-Cは最も広く用いられているC++版XML-parserのひとつです。 Apache XMLのwebサイトhttp:://xml.apache.org/からリンクをたどればXerces-CのWin32バイナリ版が入手でき、Visual C++ 6.0で利用できます。ですがこのバイナリ版にはひとつだけ困った問題があります。

Win32バイナリ版Xerces-Cをインストールし、その中のサンプル’DOMPrint’を使ってXMLをプリントしてみます。このときプリント対象となるXMLがshift_jisあるいはUNICODE(UTF-16/UTF-8)であれば何の問題もないのですが、たとえばeuc-jpやiso-2022-jpで書かれたDOMを正しくparseすることができません。

様々なencodingで書かれたXMLをプリントすると…

shift-jis

domprint -x=shift_jis sjis.xml


この文字列はshift_jisです

utf-16

domprint -x=shift_jis utf.xml


この文字列はUTF-16です

utf-8

domprint -x=shift_jis utf8.xml


この文字列はUTF-8です

euc-jp

domprint -x=shift_jis euc.xml


､ｳ､ﾎﾊｸｻﾎ､ﾏeuc-jp､ﾇ､ｹ[1]

iso-2022-jp(JIS)

domprint -x=shift_jis jis.xml
Fatal Error at file "jis.xml", line 2, column 11
   Message: Invalid character (Unicode: 0x1B)
An error occured during parsing

入力文字列をUNICODEに変換する際、XML-parserが内部で利用しているWindows-APIがiso-2022-jpやeuc-jpに対応していないからです。

Xerces-Cに添付されているHTMLドキュメントには文字コード変換にIBMのICUを利用するようにライブラリを修正する手順が明記されていますが、それによるとperlおよびUNIX-コンパチブルなshellを必要とします。ここではperlやshellを使わずにVisual C++ IDEでXerces-CをICU対応させる手順を紹介します。

※ 以下に示す手順は、2001年5月現在入手可能な最新版:

Xerces-C 1.4.0
ICU 1.8

に対応しています。

作業手順

ICUのインストールとビルド
IBM-ICUのサイトからICU1.8をダウンロードし、適当なディレクトリに展開します。以降、ICUを展開したディレクトリをと表します(ここでは m:\icu とします)。ICU-distributionに含まれる\source\allinone\allinone.dswをVC++IDEで開き、プロジェクト’all’のRelease/Debugライブラリ(DLL)をビルドします。

ビルドが完了したら\bin\icuuc.dll, \bin\icuucd.dllおよび\source\data\icudt18l.dllをPATHの通ったディレクトリにコピーしておきます。
Xerces-C Win32バイナリ版のインストール
Apache XMLのサイトからXerces-C 1.4.0 Win32バイナリ版をダウンロードし、適当なディレクトリに展開します。以降、Xerces-C Win32バイナリ版を展開したディレクトリをと表します。
Xerces-C Win32ソースコード版のインストール
Apache XMLのサイトからXerces-C 1.4.0 ソースコード版をダウンロードし、適当なディレクトリに展開します。以降、Xerces-C ソースコード版を展開したディレクトリをと表します。
Xerces-C プロジェクト設定の変更
\D:\Projects\Win32\VC6\xerces-all\xerces-all.dswをVC++IDEで開き、プロジェクト設定を以下のとおりに変更します。
- インクルード・パス \include を追加します。
- プリプロセッサ・マクロ XML_USE_WIN32_TRANSCODER を XML_USE_ICU_TRANSCODER に書き換えます。
- ライブラリ・パス \lib および \source\data を追加します。
- ライブラリ icuuc.lib(Debug版はicuucd.lib) および icudata.lib を追加します。
- ワークスペースから Win32TransService.hpp, Win32TransService.cpp を削除し、\src\util\Transcoders\ICU\ICUTransService.hpp, \src\util\Transcoders\ICU\ICUTransService.cpp を追加します。
プロジェクト ‘XercesLib’ のRelease/Debug版をビルドします。
ビルドが完了すれば \Build\Win32\Vc6\Release および \Build\Win32\Vc6\Debug に
- xerces-c_1.lib, xerces-c_1_4.dll (Release版)
- xerces-c_1D.lib, xerces-c_1_4D.dll (Debug版)
が生成されています。これらを \lib, \bin にコピーします。

確認

さて、ICU-enabled な Xerces-C の構築に成功したか、さきほどうまくいかなかったencodingによるXMLを再度 DOMPrint に食わせてみましょう。

euc-jp

domprint -x=shift_jis euc.xml


この文字列はeuc-jpです

iso-2022-jp(JIS)

domprint -x=shift_jis jis.xml


この文字列はiso2022-jpです

ちょっとした応用を考えてみましょう。XML-parserがiso-2022-jpを受け付けてくれるので、XMLドキュメントをメール(SMTP)に投げ、POP3で受け取ってparseすることができるはずです。

適当なメールアカウントに対し


このメッセージは電子メールに投げられたXMLから取り出されました

を送信し、以下のプログラムを起動すると、タグに囲まれたテキスト

このメッセージは電子メールに投げられたXMLから取り出されました

がコンソールに出力されます

// --- StdLib. (SourcePro Core)
#include 
#include 
#include 

// --- SourcePro Network
#include        // RWSocketPortal
#include       // RWPortalIStream
#include         // RWWinSockInfo
#include                 // rwNormalizeLine()
#include      // RWStreamCoupler
#include              // RWPop3Agent

// --- Xerces-C
#include             // PlatformUtils
#include              // DOMParser
#include               // ErrorHandler
#include          // SAXParseException
#include                        // DOM_xxx
#include    // MemBufInputSource

/*
 * definitions
 */

#define POP3_SVR "POP3サーバアドレス"
#define POP3_USR "ユーザ名"
#define POP3_PWD "パスワード"

/*
 * namespace
 */
using namespace std;

/*
 * ErrorHandler for DOMParser
 */
class ErrorReporter : public ErrorHandler {
  bool ok_;
public:
  ErrorReporter() : ok_(true) {}
  ~ErrorReporter() {}
  virtual void warning(const SAXParseException& ex)
    { }
  virtual void error(const SAXParseException& ex)
    { ok_ = false; }
  virtual void fatalError(const SAXParseException& ex)
    { ok_ = false; }
  virtual void resetErrors() { ok_ = true; }
  bool ok() const { return ok_; }
};

/*
 * XML-documentをparseし、
 * ドキュメント中の 'message' タグの内容を表示する
 */
int parse_message(const string& message) {
  DOMParser parser;
  ErrorReporter errReporter;
  parser.setErrorHandler(&errReporter);
  parser.setExitOnFirstFatalError(true);
  MemBufInputSource source(reinterpret_cast(message.data()),
                           message.length(),
                           L"application/xml");
  parser.parse(source);
  if ( !errReporter.ok() ) {
    return 1;
  }
  DOM_Document document = parser.getDocument();
  DOM_NodeList nodes = document.getElementsByTagName("message");
  for ( unsigned i = 0; i < nodes.getLength(); ++i ) {
    DOM_Node node = nodes.item(i);
    if ( node.getNodeType() != DOM_Node::ELEMENT_NODE ) {
      continue;
    }
    char* message = node.getFirstChild().getNodeValue().transcode();
    cout << message << endl;
    delete[] message;
  }
  return 0;
}

/*
 * POP3からメールを取り出し、メッセージをparse_message()へ
 */
int get_mail() {
  RWPop3Agent agent(POP3_SVR, POP3_USR, POP3_PWD);
  int n = agent.messages();
  for ( int i = 1; i <= n; ++i ) {
    RWSocketPortal portal = agent.get(i);
    RWPortalIStream istrm(portal);
    RWCString text;
    bool body = false;
    do {
      text.readLine(istrm, false);
      text = rwNormalizeLine(text);
      if ( text.isNull() ) {
        body = true;
        break;
      }
    } while ( text != "." );
    ostringstream ostrm;
    if ( body ) {
      RWStreamCoupler couple;
      couple(istrm, ostrm, pop3StreamFilter);
      agent.removeMessage(i);
      parse_message(ostrm.str());
    }
  }
  return 0;
}

/*
 * メイン
 */
int main(int argc, char* argv[]) {
  locale::global(locale("japanese"));
  try {
    RWWinSockInfo info;
    XMLPlatformUtils::Initialize();
    get_mail();
  } catch ( RWxmsg& rwer) {
    cerr << "Exception : " << rwer.why() << endl;
  } catch ( std::exception& stder ) {
    cerr << stder.what() << endl;
  }
  XMLPlatformUtils::Terminate();
  return 0;
}

編集部注

^ 文字化けした結果をWebサイト上で表現するために、実際の出力を一部加工しています。

XMLを用いた永続オブジェクトの試み

cpptechdoc — Thu, 06 Apr 2006 05:56:06 +0000

永続オブジェクトとXML

近頃XMLがやたらとクローズアップされてきています。サーバ/サーバ間あるいはクライアント/サーバ間のインタフェースとしてXMLを用いることで様々な接続に対応できるってことで、e-commerceをはじめとしたITの基礎技術として脚光を浴びてきたということでしょう。(e-commerceについては僕には良くわからないし、そんなbigなシステムを構築するつもりはありません^^;)

XMLで遊んでいると様々な使いみちを思い付きます。アプリケーションの設定情報なんかをXMLで書くとか、状態遷移表をXMLで表現するとか…

XMLは階層構造を持ったデータを表現する汎用のデータ・フォーマットです。階層構造を持ったデータを表現できるのなら、オブジェクトをXMLで表現できるだろうと考えました。たとえば、

class person {
  string name_; // 名前
  int    age_;  // 年齢
public:
  person(string n, int a) : name_(n), age_(a) {}
  ...
};

のようなオブジェクトがあったとき、person(“adam”,24) を

<person>
  <name>adamname>
  <age>24age>
person>

のようなXMLに変換すること、逆にXMLからpersonを生成することができるんじゃないか…というわけ。

これができればアプリケーションが扱うオブジェクトの集合をXML化でき、XMLによるアプリケーション間でのオブジェクトのやりとりが可能になります。

…というわけで、XMLによるオブジェクトの永続化の試みです。

※このアーティクルでは、Microsoft XML Parser (MSXML.dll) を用いますが、XML4C や Xerces などXML Parserでも考え方は同じです。

書き込みメカニズム

例として

class person {
  string name_; // 名前
  int    age_;  // 年齢
public:
  person(string n, int a) : name_(n), age_(a) {}
  ...
};

をXML化することを考えます。そのために新たなメソッドvirtual void save(IXMLDOMNodePtr node) constを追加します。

※IXMLDOMNodePtrはMSXMLにおけるDOMNodeのスマート・ポインタです。

メソッド save は、自分自身のメンバに基づいて DOMNode を生成します。たとえば name_ == "adam" , age_ == 24 であるpersonオブジェクトからは

<person>
  <name>adamname>
  <age>24age>
person>

なるDOMNodeを生成します。

次に、生成された DOMNode を引数 node の子エレメントとして追加します。たとえば node が (あるいは) であるとすると、

<root>
  <person>
    <name>adamname>
    <age>24age>
  person>
root>

となります。node が既に子エレメントを持っていた場合、その末っ子として追加します。

まず、メソッド save の冒頭では、

[1] “person” をタグ名とする DOMElement を作る

を行ないます。

次にメンバ変数name_からadam なるDOMNodeを作るには､

[2] name_の値を文字列化し、それを値とする DOMText を作る
[3] “age” をタグ名とする DOMElement を作る
[4] [3]の子ノードとして[2]を追加する

というステップを踏みます。

これでふたつの DOMNode :

[1]
[4] adam

ができたので、

[5] [1]の子ノードとして[4]を追加する

を行ないます。

全く同様に age_ から24 なるDOMNode を作り、[1]の子ノードとして追加します。

最後に、save の引数として与えられた node の子ノードとして[1]を追加します。ここまでを実装してみましょう:

    void person::save(IXMLDOMNodePtr node) const {
      assert(node != 0);

      IXMLDOMDocumentPtr doc  = node->ownerDocument;
      IXMLDOMNodePtr     elem = doc->createElement("person");
      IXMLDOMNodePtr     item;
      IXMLDOMTextPtr     text;

      item = doc->createElement("name");
      text = doc->createTextNode(name_.c_str());
      item->appendChild(text);
      elem->appendChild(item);

      item = doc->createElement("age");
      char buff[16];
      _itoa(age_,buff,10);
      text = doc->createTextNode(buff);
      item->appendChild(text);
      elem->appendChild(item);

      node->appendChild(elem);
    }

personの派生クラス:

class programmer : public person {
  string lang_; // 言語
  ...
};

のメソッドsave(IXMLDOMNode node) constでは、ベースクラスのメソッドsaveを再帰的に呼び出します。すなわち、

[6] “programmer” をタグ名とする DOMElement を作る
[7] [6]を引数にベースクラス(person)のsaveを呼び出しことで、[6]の子ノード... を追加する
[8] メンバ変数 lang_ に基づいて...を作る
[9] [6]の子ノードとして[8]を追加する

実装は以下のようになります:

    void programmer::save(IXMLDOMNodePtr node) const {
      assert(node != 0);

      IXMLDOMDocumentPtr doc = node->ownerDocument;
      IXMLDOMNodePtr elem  = doc->createElement("programmer");
      IXMLDOMNodePtr item;
      IXMLDOMTextPtr text;

      person::save(elem);

      item = doc->createElement("language");
      text = doc->createTextNode(lang_.c_str());
      item->appendChild(text);
      elem->appendChild(item);

      node->appendChild(elem);
    }

これによって、programmerからは以下のような DOMNode が生成されることになります:

<programmer>
  <person>
    <name>billname>
    <age>31age>
  person>
  <language>BASIClanguage>
programmer>

最後に、XMLとしての体裁を整える、すなわち、

[10] DOMDocument を生成する
[11] rootエレメントを作る
[12] [11]で作ったrootエレメントに対し、オブジェクト(person or programmer)をsaveする

という処理を行なうことでXMLによる永続データの完成です。

  int save(string file) {

    // 空のドキュメントを生成する
    IXMLDOMDocumentPtr doc("MSXML.DOMDocument");
    doc->appendChild(
      doc->createProcessingInstruction(

    // ルートエレメントを生成する。
    IXMLDOMNodePtr root = doc->createElement("root");
    doc->appendChild(root);

    // [1] personとprogrammerをrootにsave
    cout << "save person & programmer¥n";
    person("adam",24).save(root);
    programmer("bill",20,"BASIC").save(root);

    // [2] vectorを生成
    vector pv;
    pv.push_back(programmer("bjarne",28,"C++"));
    pv.push_back(programmer("wirth",30,"Modula-2"));

    // [3] rootの子"programmers"を作り、
    // その中にvectorをsave
    cout << "save programmers¥n";
    IXMLDOMNodePtr pvelm = doc->createElement("programmers");
    for ( int i = 0; i < pv.size(); ++i )
      pv[i].save(pvelm);
    root->appendChild(pvelm);

    // XMLファイルを出力
    doc->save(file.c_str());
    return 0;
  }

上記のサンプルコードによって生成されたpersist.xmlをIE5でブラウズしたイメージを以下に示します:

読み込みメカニズム

読み込みは前述の書き込みと同じ順序で DOMNode をほどいてゆきます。

すなわち personのメソッド void load(IXMLDOMNodePtr node)では、

[1] 最初の子ノード(...)を取得する
[2] [1]の子ノード(DOMText)を取得する
[3] [2]から得られる文字列を基にメンバ変数 name_ をセットする
[4] 次の子ノード(...)を取得する
[5] [4]の子ノード(DOMText)を取得する
[6] [5]から得られる文字列を基にメンバ変数 age_ をセットする

    void person::load(IXMLDOMNodePtr node) {
      assert(node != 0);
      assert(node->nodeName == _bstr_t("person"));

      IXMLDOMNodePtr item;
      IXMLDOMNodePtr text;

      item = node->firstChild;
      text = item->firstChild;
      name_ = static_cast(_bstr_t(text->nodeValue));

      item = item->nextSibling;
      text = item->firstChild;
      age_ = atoi(static_cast(_bstr_t(text->nodeValue)));
    }

同様に programmer::load(IXMLDOMNodePtr node) では:

[7] 最初の子ノード(...)を取得する
[8] [7]を引数にベースクラス(person)のメソッドloadを呼び出し、ベースクラスのメンバ変数をセットする
[9] 次の子ノード(...)を取得する
[10] [9]の子ノード(DOMText)を取得する
[11] [10]から得られる文字列を基にメンバ変数 lang_ をセットする

    void programmer::load(IXMLDOMNodePtr node) {
      assert(node != 0);
      assert(node->nodeName == _bstr_t("programmer"));

      IXMLDOMNodePtr item;
      IXMLDOMNodePtr text;

      item = node->firstChild;
      person::load(item);

      item = item->nextSibling;
      text = item->firstChild;
      lang_ = static_cast(_bstr_t(text->nodeValue));
    }

永続データ(すなわちXML)からオブジェクトを復元するには:

[12] XMLをパースし、DOMDocument を取得する
[11] [12]からrootエレメントを取得する
[12] [11]で作ったrootエレメントに対し、オブジェクト(person or programmer)をloadする

という処理を行なうことになります。

  int load(string file) {

    IXMLDOMDocumentPtr doc("MSXML.DOMDocument");
    doc->validateOnParse = VARIANT_FALSE;
    doc->load(file.c_str());

    IXMLDOMNodePtr root = doc->documentElement;
    IXMLDOMNodePtr node;

    // save:[1] でsaveした person/programmer を読み出す
    cout << "¥nload person & programmer¥n";
    int i;
    person* p;
    node = root->firstChild;
    p = node->nodeName == _bstr_t("person") ? new person : new programmer;
    p->load(node);
    p->print(cout);
    cout << endl;
    delete p;

    node = node->nextSibling;
    p = node->nodeName == _bstr_t("person") ? new person : new programmer;
    p->load(node);
    p->print(cout);
    cout << endl;
    delete p;

    // save:[3] でsaveしたvectorを読み出す
    cout << "¥nload programmers¥n";
    vector pv;
    node = node->nextSibling;
    for ( node = node->firstChild; node != 0; node = node->nextSibling ) {
      programmer p;
      p.load(node);
      pv.push_back(p);
    }

    for ( i = 0; i < pv.size(); ++i ) {
      pv[i].print(cout);
      cout << endl;
    }

    // saveされたpersonを出力
    // このとき、programmerが内包するpersonも含む
    cout << "¥nload persons (including programmers)¥n";
    IXMLDOMNodeListPtr nodes = doc->getElementsByTagName("person");
    for ( i = 0; i < nodes->length; ++i ) {
      person p;
      p.load(nodes->item[i]);
      p.print(cout);
      cout << endl;
    }

    return 0;
  }

上記コードの実行結果は以下のようになります:

サンプルコード

#include  // ostream
#include    // string
#include    // vector
#include   // assert
#include   // atoi, _itoa

#import "msxml.dll" rename_namespace("msxml")

namespace msxml {

  /*
   * テストのための2つのクラス : person と programmer
   */
  class person {

    std::string name_;
    int         age_;

  public:

    person(std::string name, int age)
      : name_(name), age_(age) {}
    person() {}

    virtual void save(IXMLDOMNodePtr node) const {
      assert(node != 0);

      IXMLDOMDocumentPtr doc  = node->ownerDocument;
      IXMLDOMNodePtr     elem = doc->createElement("person");
      IXMLDOMNodePtr     item;
      IXMLDOMTextPtr     text;

      item = doc->createElement("name");
      text = doc->createTextNode(name_.c_str());
      item->appendChild(text);
      elem->appendChild(item);

      item = doc->createElement("age");
      char buff[16];
      _itoa(age_,buff,10);
      text = doc->createTextNode(buff);
      item->appendChild(text);
      elem->appendChild(item);

      node->appendChild(elem);
    }

    virtual void load(IXMLDOMNodePtr node) {
      assert(node != 0);
      assert(node->nodeName == _bstr_t("person"));

      IXMLDOMNodePtr item;
      IXMLDOMNodePtr text;

      item = node->firstChild;
      text = item->firstChild;
      name_ = static_cast(_bstr_t(text->nodeValue));

      item = item->nextSibling;
      text = item->firstChild;
      age_ = atoi(static_cast(_bstr_t(text->nodeValue)));
    }

    virtual void print(std::ostream& strm) const {
      strm << name_ << '(' << age_ << ')';
    }

  };

  class programmer : public person {

    std::string lang_;

  public:

    programmer(std::string name, int age, std::string lang)
      : person(name,age), lang_(lang) {}
    programmer() {}

    virtual void save(IXMLDOMNodePtr node) const {
      assert(node != 0);

      IXMLDOMDocumentPtr doc = node->ownerDocument;
      IXMLDOMNodePtr elem  = doc->createElement("programmer");
      IXMLDOMNodePtr item;
      IXMLDOMTextPtr text;

      person::save(elem);

      item = doc->createElement("language");
      text = doc->createTextNode(lang_.c_str());
      item->appendChild(text);
      elem->appendChild(item);

      node->appendChild(elem);
    }

    virtual void load(IXMLDOMNodePtr node) {
      assert(node != 0);
      assert(node->nodeName == _bstr_t("programmer"));

      IXMLDOMNodePtr item;
      IXMLDOMNodePtr text;

      item = node->firstChild;
      person::load(item);

      item = item->nextSibling;
      text = item->firstChild;
      lang_ = static_cast(_bstr_t(text->nodeValue));
    }

    virtual void print(std::ostream& strm) const {
      person::print(strm);
      strm << ':' << lang_;
    }

  };

  /*
   * お試し
   */
  using namespace std;

  int save(string file) {

    // 空のドキュメントを生成する
    IXMLDOMDocumentPtr doc("MSXML.DOMDocument");
    doc->appendChild(
      doc->createProcessingInstruction(

    // ルートエレメントを生成する。
    IXMLDOMNodePtr root = doc->createElement("root");
    doc->appendChild(root);

    // [1] personとprogrammerをrootにsave
    cout << "save person & programmer¥n";
    person("adam",24).save(root);
    programmer("bill",20,"BASIC").save(root);

    // [2] vectorを生成
    vector pv;
    pv.push_back(programmer("bjarne",28,"C++"));
    pv.push_back(programmer("wirth",30,"Modula-2"));

    // [3] rootの子"programmers"を作り、
    // その中にvectorをsave
    cout << "save programmers¥n";
    IXMLDOMNodePtr pvelm = doc->createElement("programmers");
    for ( int i = 0; i < pv.size(); ++i )
      pv[i].save(pvelm);
    root->appendChild(pvelm);

    // XMLファイルを出力
    doc->save(file.c_str());
    return 0;
  }

  int load(string file) {

    IXMLDOMDocumentPtr doc("MSXML.DOMDocument");
    doc->validateOnParse = VARIANT_FALSE;
    doc->load(file.c_str());

    IXMLDOMNodePtr root = doc->documentElement;
    IXMLDOMNodePtr node;

    // [1] でsaveした person/programmer を読み出す
    cout << "¥nload person & programmer¥n";
    int i;
    person* p;
    node = root->firstChild;
    p = node->nodeName == _bstr_t("person") ? new person : new programmer;
    p->load(node);
    p->print(cout);
    cout << endl;
    delete p;

    node = node->nextSibling;
    p = node->nodeName == _bstr_t("person") ? new person : new programmer;
    p->load(node);
    p->print(cout);
    cout << endl;
    delete p;

    // [3] でsaveしたvectorを読み出す
    cout << "¥nload programmers¥n";
    vector pv;
    node = node->nextSibling;
    for ( node = node->firstChild; node != 0; node = node->nextSibling ) {
      programmer p;
      p.load(node);
      pv.push_back(p);
    }

    for ( i = 0; i < pv.size(); ++i ) {
      pv[i].print(cout);
      cout << endl;
    }

    // saveされたpersonを出力
    // このとき、programmerが内包するpersonも含む
    cout << "¥nload persons (including programmers)¥n";
    IXMLDOMNodeListPtr nodes = doc->getElementsByTagName("person");
    for ( i = 0; i < nodes->length; ++i ) {
      person p;
      p.load(nodes->item[i]);
      p.print(cout);
      cout << endl;
    }

    return 0;
  }

  int entry(string file) {
    int result;
    if ( result = save(file) ) return result;
    if ( result = load(file) ) return result;
    return result;
  }

}

using namespace msxml;

int main(int argc, char* argv[]) {
  if ( FAILED(CoInitialize(0)) ) return 1;
  int result = entry("persist.xml");
  CoUninitialize();
  return result;
}

オブジェクト指向とはなにか

cpptechdoc — Thu, 06 Apr 2006 05:43:34 +0000

日常生活の中のオブジェクト

私たちの身の回りには、自分で直接できることと自分では直接できないこととがあります。朝おきて何気なく読む新聞も、新聞社という組織が作り、近くの販売所が毎日届けてくれます。私たちが新聞を読むときには、誰がどのようにして作っているかを知る必要はありません。

また、あなたがエレベータに乗るときも、あなたは自分のいる階でボタンを押せばいずれエレベータがやってくると期待しているのです。それは、世の中にあるエレベータという乗り物がおおむねその様な動きをしていることを知っているからです。

駅まで行き、電車に乗る場合でも同じです。電車は、どこかの鉄道会社が作ったダイヤに従って動いているのです。あなたが、どの電車はこのように動きなさい、と規定するわけではありません。

通りでタクシーを拾う場合もそうです。あるタクシーは客待ちをしており、また、あるタクシーは街の中を流して客を探しているでしょう。しかし、タクシーを利用するときに、すべてのタクシーがどのような動きをしているかを知らなくてもよいのです。しかも、たいていは、目的地までの道順をあなたが知らなくても、目的地にたどり着くことができます。

私たちひとりひとりが個人で知り得る知識や個人で直接行える事柄には限りがありますが、それにもかかわらず私たちがさまざまなことをなし得るのは、社会のしくみそのものが、私たちの意志とは無関係に、ある一定のルールにしたがって自立的に動いているからなのです。

エレベータも電車もタクシーもその使い方さえ知っていれば使える便利な「もの」なのです。これをオブジェクトと呼ぶことにしましょう。

さて、今度はソフトウェアの世界のことを考えてみましょう。普通のソフトウェアのシステムの世界で何かやろうとするときに、ひとつの仕事をサブルーチン（手続きの流れを記述したソフトウェアの構成要素）という形で記述することがあります。しかし、このサブルーチンは私たちの世界の中のエレベータや電車のようなシステムにはなっていません。なぜならサブルーチンは、それを使うときになって初めて生成され、それ以外のときには存在しないからです。

ソフトウェアの世界でエレベータに乗るということを考えた場合、いったいどのようなことになるのでしょうか。従来のソフトウェアの世界では、まずエレベータのサブルーチンが初期化されます。初期化に従って1階にいるとか10階にいるとかが決まり、サブルーチンはその状態に従わなければなりません。つまり、エレベータそのものの動きを使う人が知っていなければ、ソフトウェアの世界ではエレベータを使うことができないのです。また、既存のサブルーチンを寄せ集めて何かをするということもできず、何かをしたいときは新しくサブルーチンを作って初期化して使わなければならないのです。

果たしてこのやり方は本当に便利なのでしょうか。ソフトウェアの世界も大きくなってくると、プログラムを細部まで把握して管理することが困難になってきます。もし各サブルーチンが、現実の世界の中のエレベータや電車のように、自分自身を管理しているオブジェクトであったらどうでしょうか。

この場合には、各オブジェクトの使い方さえ把握していれば、それらの動き（規定されたルール）について細かく知らなくても各オブジェクトを使うことができます。ソフトウェアの世界でもオブジェクトが使えれば私たちの日常生活のようにシステムが構築でき、私たちにとっては非常に使いやすいシステムにすることができるのです。

新しいパラダイム

人間の知的能力にはさまざまな側面があります。新しいものを作り出す創造的な能力、機械には不得手な言語理解やパターン認識の能力、数学などで要求される論理思考能力などさまざまです。日常生活の中では、私たちの思考や発言はいつも論理的であるとは言えません。むしろ情緒的で概念的でかなりあいまいなものです。実は論理的思考を長く続けることはかなり骨の折れることと言えるのです。

いままでのプログラミング言語はコンピュータの動作ルールに依存した特殊ともいえる論理一辺倒のものが大部分で、プログラムを組む際にも特殊な論理的思考能力が要求されています。人間がプログラムを組むときにエラーが発生し、デバッグが余儀なくされるのは、人間がこのような論理的思考を長く持続していくことを得手としていないことに起因しているといえるでしょう。

では、ソフトウェアの世界をもっと、人間の側に近づけることはできないでしょうか。コンピュータに何かをさせようとするとき、従来のプログラミング言語では、コンピュータの動きにそって個別の事象を記述しなければなりませんでした。つまり、先ほどの例を用いれば、エレベータに乗りたいときエレベータの設計・製造から起動方法に関する記述まですべてを行わなければ、エレベータに乗ることはできませんでした。

しかし、本来の目的はただエレベータに乗りたいわけですから、私たちの世界のように、エレベータに関する設計や製造などは考えずに、誰かが作っておいてくれているものを利用すればそれを呼ぶだけでエレベータに乗ることはできるはずです。また、こうしてエレベータに関して記述されたものは他のところでも利用できるのです。

このようなソフトウェアの世界が実現できたらどんなに素晴らしいことでしょうか。実はこれがオブジェクト指向が登場した理由の1つといえるのです。

では、もう少し具体的にソフトウェアの世界での「オブジェクト」はどのような存在であればよいのかを考えてみることにしましょう。それは、端的に言うならば、データの部分と手続きの部分が切り離されずにひとつになっているものと言えます。

実は現実の世界ではこの方がずっと自然な考え方です。これだけではわかりにくいので先程の例で考えてみましょう。

エレベータの場合、エレベータの箱（人が乗る部分）や各フロア、各フロアにあるエレベータの扉がデータとなり、モーターを回すとか、扉を開閉するという操作が手続きになります。データと手続きが一緒になっていると自己管理能力が出てきます。ソフトウェアについても、もっと人間に近いレベルで考えたほうが便利です。そのアプローチのひとつがオブジェクト指向なのです。これは、いつも人間が物を見ている見方と適合するものなのです。

なぜオブジェクトか

オブジェクトという形にしておけば、ソフトウェアのモジュラリティが非常に良くなります。このモジュラリティが良いと言うことは、たとえて言うと、1つのシステムが積み木のように1つ1つを組み合わせてできているということです。モジュラリティが良くなると、メンテナンスがしやすくなります。古くなって調子の悪い積み木は、その外形が同じであれば、取り換えることができます。

このことはソフトウェアを財産化する道につながるのです。なぜなら、誰かが作った積み木をそのまま、他の人が使ってシステムを作り上げることができるからです。最高の品質を持つ積み木は、いろいろな人がシステムを作るときに利用することになります。これが財産になるのです。ここでは、このことについて、もう少し詳しく見ていきましょう。

プログラムの部品化

これまでのプログラミング言語では、あるシステムを記述していく場合、いわば何もない状態から始めなければなりませんでした。プログラムを作るたびに、同じような目的のサブルーチンを作らなければならなかったのです。

しかし、オブジェクト指向型言語では、それまでにプログラムされたことがすべて蓄積として残されます。オブジェクトというデータ構造（データ+手続き）のために、部品として何度でも利用できるのです。

つまり、オブジェクト指向型言語におけるプログラミングでは、それまで培われてきたプログラムを部品として付け加えたり取り除いたり、また改良を加えたりすることが自由にできるのです。

この部品は、ハードウェアの部品と違って、部品と部品の結合がロジカルなものであるので、1つの部品が同時にいくつもの部品と結合することができるわけです。部品化が可能であると以下のようにいくつもの利点が生まれます。

メンテナンスの容易性

よいソフトウェアは長く使われます。しかし、長く使っている間には手直しが必要になります。手直しの仕方もこれまでのやり方は、パッチワーク的なやり方で、つぎあてをしていました。

しかし、どんなによいソフトウェアでも、このような直し方をしているとしだいに複雑になってしまい、最後には手直しをするくらいなら新たにプログラム全体を作り上げるほうが楽である、というようなことになってしまいます。そんなことをしていては効率が悪いので、もっと本質的に異なるプログラムを作っておくことが必要なわけです。

たとえばデータベースの場合、最初にデータのフォーマットを決めてしまったとします。そのデータ構造にアクセスするような仕組みを今までのソフトウェア・システムで書いたとすると、そのカラム数を変えたくなったときに、その部分を変更すると、そのデータをアクセスしているソフトウェアをすべて書き換えなければならなくなりました。しかし、部品化しておけば、その部分だけを取り換えるだけでよいのです。

それでは、このような部品化はBASICやFORTRANのような手続き型言語ではできないのでしょうか。ソフトウェアを大きな部品から小さな部品へと順次細分化しながら作ってゆくトップダウン設計の手法を使えば、部品化はできます。オブジェクト指向ではなくてもモジュール化しておけば、上のルーチンとは関係なしに必要な部分だけ変えればよいようにできるのです。

しかし、手続き型言語には問題があります。では、どのような問題があるのでしょうか。

手続き型言語でソフトウェア・システムを作るやり方としては、モジュール化するやり方とモジュール化しないやり方の2通りがあります。モジュール化すると速度が遅くなるので、ある部分はモジュール化しないでおきましょうということもできます。そして、一度このようにモジュール化されていない部分がソフトウェア・システムの中に組み込まれてしまうと、あるサブルーチンが勝手気ままにあるデータを使用するという現象を起こし、そのシステムは全体としてみた場合、モジュール構造を持つことについての保証がまったくなくなってしまうのです。

ハードウェアの能力が低く、ソフトウェア・システムの処理速度が問題にされた時代には、モジュール化されずに作られたものが多かったようです。考えようによっては、手続き型言語には柔軟性があるということにもなりますが、実はこれがシステムに悪影響を与えることがあるのです。

オブジェクト指向言語の場合はどうでしょう。オブジェクト指向型言語では、必ずモジュール化しないとプログラムが書けないのです。そこがオブジェクト指向型言語と手続き型言語の大きな違いです。

もちろん、質の高いプログラマーはどのような言語を使用しても、ソフトウェアをモジュール化して、後の変更に対して強いシステムを書くでしょうが、入門したばかりのプログラマーではそういう書き方が必ずしもできるわけではありません。ここに落とし穴があるわけです。たとえば、作業を分担してプログラムを作った場合、ある部分はモジュール化されているのに、別の部分はモジュール化されていないということが起こります。

オブジェクト指向型言語では、モジュール化しないとプログラムが書けないということが、メンテナンスのしやすさを保証しているのです。メンテナンスしやすいということは、ソフトウェア・システムの作り方にも大きな変革をもたらしました。これが次に述べるプロトタイピングです。

プロトタイピングという手法により、これまでの要求仕様定義のように固定的な方法から、もっとダイナミックに仕様を変更していける道が開けたのです。そして、これを実現したのがオブジェクト指向型言語なのです。

オブジェクト指向分析/設計

「ソフトウェアについても、もっと人間に近いレベルで考えたほうが便利です。」と述べました。

これは実装（製造）だけにとどまらず、前工程である分析/設計においても同じです。ソフトウェアの開発とは、現実世界をモデル化し、さらにそのモデルを計算機世界にマッピングする作業といえます。

現実世界をモデル化する（何を作るかを定義する）作業がすなわち分析、モデルの計算機世界へのマッピング（どう作るかを決定する）作業が設計および製造です。であれば、現実世界から計算機世界までの一連の変換作業を「人間が物を理解するやり方」に近い、オブジェクト指向で通すのが自然です。

従来の設計手法では、機能モジュールに分割し、そしてそのそれぞれをブレークダウンしていました。この手法は機能を骨組みとしたやり方です。作成された設計書あるいはコードは機能を柱とした構造を持っています。ソフトウェアの変更や改造はほとんどの場合機能の変更/改造ですから、場合によってはソフトウェアの構造を根幹から揺るがすことになりまねません。

オブジェクト指向分析/設計では、そのシステムを構成する「もの」とその関連が骨組みとなります。機能的な変更/改造が「もの」そのもの、あるいは「もの」の間にある関連を大きく揺さぶることはまれです。オブジェクト指向によるソフトウェア開発が変更/改造に強いといわれるのは、機能を骨組としていないからです。

ソフトウェア開発の前工程、すなわち分析や設計におけるオブジェクト指向はどんな意味を持っているのでしょうか。

もちろん実装の過程でオブジェクト指向型言語を使用する場合においては、前段階からオブジェクト指向に基づいた分析/設計を行っておけばアイデアと実装とのギャップを小さくできる、言い換えれば「アイデアがそのままコードになる」境地に近づくことができるのはいうまでもないことですが、従来の手続き型言語で実装するにしてもオブジェクト指向分析/設計のメリットはあると考えます。

それは、オブジェクト指向型言語が実装面での再利用性を高めると同様に、オブジェクト指向分析/設計が分析/設計フェーズでの再利用に有効なのです。

たとえば「時計」を設計したとしましょう。時計には「時刻合せ」と「時を刻む」という大きな機能があります。時計の満たすべき基本的な条件と機能とをオブジェクト指向分析/設計できちんと定義しておけば、その後「タイムレコーダ」を設計する際に、時計の設計書が再利用できます。すなわち、「タイムレコーダは時計の一種である。基本的な条件/機能は時計の設計書を参照のこと。タイムレコーダを実現するにあたり、時計とは異なる項目、および追加すべき項目を以下に述べる」などと設計書の冒頭に書き、時計との差分/追加分のみを記述すればタイムレコーダ設計書のできあがりとなるならなんて楽でしょう。

いわば設計書のライブラリ化が可能となります。

Ｃ＋＋学習のために

オブジェクト指向と言う言葉がパソコン世界のいたる所に浸透してきておりその概念を知っていないと置いていかれると言う状況になってきました。

多くの資料がありプログラミング上での勉強の資料に事欠きませんがプログラミング上での資料ですからパソコンの世界でのオブジェクトとなると対象が広いだけに曖昧模糊としてつかみどころのないものになっています。

特定の言語に依存してしまう「オブジェクト指向言語」の資料ではその言語自体をマスターしていなくては理解できず言語を理解するにはオブジェクト指向の概念を理解していなければならないというパラドックスで初心者にはお手上げ状態になっています。

さて、プログラミング用語であると思われるオブジェクト指向をアプリケーションを使う側で知るべきかという点でオブジェクト指向の何たるかを知っているのと知らないのとでは天国と地獄の差が出てきます。

ですのでこの原稿では本来のプログラミングと言う観点からはピントのずれている箇所もありますし、オブジェクト指向を取り入れているアプリケーション、言語は列挙するだけで膨大な数になりその中で使用される用語も大同小異と言ったものから小同大異と言えるものまでありますのでこの原稿では広く使用されている用法を表記解説しますことをまずお断りします。

そしてオブジェクト指向の概念を解説するという大それた考えはまったくなく、おじさんたちへの理解の一歩を踏み出すためのきっかけとなれば幸いとの考えで書き連ねますからこの原稿の後それなりの本格的オブジェクト指向の書籍を読む事をお薦めいたします。

ではさっそくオブジェクト指向の勉強における最低限の知識習得にはいります。

まずオブジェクト指向全体に触れなくてはなりません、結論から言うと「オブジェクトを中心にする考え方」で今までの操作手順を中心にする考え方は手続き指向と言います。

オブジェクトと言う意味は「(知覚できる)物,又は物体」と言うことですが、使用方法から言うと広義の意味と狭義とがあります。

このことをわかり易く解説しますと

ディスプレイの画面上にある広さを持つ枠（土台）がありその中にボタンが一つ配置されボタンをマウスカーソルなどで押すと簡単なメッセージを表示すると言う簡単なプログラムがあるとします。

この例でボタンが表示されている土台部分をフォームと言います、そしてフォームもボタンもオブジェクトで、「ボタンが」押されるなどの行為に反応するプログラムがボタンの部分に関連して書き込まれていない限り「単にボタンを表示する」だけのものです（ボタンなどのパーツと言って良いものを狭義の意味でのオブジェクトと言うことがおわかりだと思います)

ボタンが押された時に実行されるものをメソッドと言いますがプログラムにおける「手続き」と言う意味です、このメソッドがボタンと言うオブジェクトに書き加えられことでプログラムが完成されます。

Visual BasicCやExcelなどを学んでいる方には周知のことですが、これらの言語やアプリケーションでは基本になるフォームもボタンも最初から用意されていますのでフォーム上にボタンを配置してボタンを押したら表示する文章をボタンに書き加えるだけで簡単にプログラムが完成します。

ぐだくだと頭からフォームやボタンの形態の記述はいりません、なぜこんな簡単なことでプログラムが完成するのでしょうか、それはオブジェクト(各パーツ)が全て独立しているからにほかなりません、「知覚される物」がオブジェクト指向の基本概念です。

先の「物又は物体」を広義でオブジェクトと言うのがおわかりと思います。

独立したオブジェクトがただ単に独立して動作するだけではなんのメリットもありませんし単純作業しかこなせないものでしかありません。

独立しつつも複雑な連携を実行するが、それをユーザーに感じさせない。これが求められているのです。

そのための考えが

カプセル化 : Encapsulation
継承 : Inheritance
多態性 : Polymorphism

という３つの概念です。

カプセル化

カプセル化とは「データとルーチンが一体化されている」ことを指します。プログラム言語ではレコード型（Ｃ言語などでは構造体となります）の定義は「異なったデータをひとかたまりとして扱う」と言う点でした、この異なったデータと言う部分を「データの代わりにメソッドや関数をも記述できる」としていただければ理解できると思います。

データとメソッドが単に一緒になっていればよいのではなくデータに対する操作方法がすべて記述されていなくてはなりません、ということはデータはメソッドで保護されメソッドを通してのみ操作できるということが必要になります。

データとメソッドを一つのものとして扱いさらにはデータにアクセスするにはデータと一体化されているメソッドを通してしか接することができません、これによってデータの内容を知らなくてもメソッドの使い方さえ分かればデータの操作ができます。

データの安全性が高まるのです、実にシンプルな考え方で、これ以上何物でもありません。

カプセル化と言う言葉に惑わされてはいけません基本理念は「データの保護」と言うことです、データの保護のためにメソッドが一緒にされ、さらに保護のためにメソッドを通さなければならないのです。

継承

カプセル化の次は「継承」です、継承とは読んで字のごとく「継承＝引き継ぐ」と言うことになります、なにがなにを引き継ぐかと言いますと今あるオブジェクトのデータとメソッドを別のオブジェクトが引き継ぎオブジェクト間で上位、下位と言う関係を作ることを言います。

元になるクラスを「BaseClass」と言いそこから派生したクラスを「DerivedClass」と言います。

ここで言うクラスはプログラム言語によって若干の違いがあります、カプセル化された一単位のデータとメソッドを指す考え方、そしていくつかの似通ったオブジェクトをまとめてクラスという表現をする考え方で通常こちらの考え方を「クラス」として使います。

似通ったオブジェクトをまとめて表現することをオブジェクト指向用語風に書くと

「機能や性質に共通点があるオブジェクトの総称」となります。

例えとして「乗り物−自動車−乗用車−『の中の大衆車クラス』にはサニー、カローラ、シビック等がある」と言う言い回しでこの場合のクラスと言う表現がわかると思います。

そしてこのクラスは階層構造を作る事が多く、オブジェクト指向の参考書などでは「系図」などとして取り上げられているますので簡単に理解できると思います。

さて継承は上位の特徴と言えるものを下位が引継ぐと言うことですが逆に言うと既にあるクラスを利用して新しいクラスを作ることができると言う事になります。

新たなクラスを作る場合、既に記述してあるクラスの機能を一々新たなクラス内で記述しなおすことは非能率でしかありません。

既にある機能を継承できれば新しい機能だけを継ぎ足すだけでいとも簡単に新たなクラスを作ることができることになります。

通常継承をインヘリタンスと表記しますが、この言葉自体はなんら意味を持ちません、単に継承を読み換えているだけと理解して下さい、ただし言葉上では単なる継承ですが機能上、自身のクラスに存在しないメソッドの実行を求められた時、上位クラスに定義されているメソッドの実行で代用する事を含んでいることに注意して下さい。

最初から設計をしっかりしておけばインヘリタンスを無理して取り入れる事もないのではと言う疑問も出てきますがインヘリタンスはオブジェクト指向における重要な要素となっていると言うことはそれなりの理由があっての事です。

ポットにミルと言う機能付け加えるだけでいとも簡単にミル付きコーヒーポットができます（物としては簡単ではないでしょうがが）ビデオカメラを継承してテレビと言う機能を付け加えれば新たな機種が出来上がります。

これらは物としての考えですがこれをプログラムなどに導入したと考えてください、オブジェクトで言うインヘリタンスの意味するところがおぼろげながら見えてきたはずです。

さらに便利なことに上位のオブジェクトで定義された機能を下位のオブジェクトで書き直すことができます、全て継承することもなく又継承したくない部分を書き換えてしまうことが許されておりそれをオーバーライド（override）と呼びます。

ここで継承＝インヘリタンスをまとめますと

既にあるクラスを利用して新しいクラスを作る。
新しいデータやメソッドを追加できる。
上位のデータやメソッドを定義し直せる。

ということになります。

１と２は表裏一体の関係と言えます、新しいデータやメソッドを追加せずただ継承だけではなんら必要性が認められないからです。

３のオーバーライドもこの後で軽く触れる「多態性」では意味を失いますが現在は素直に受け取っていただいて結構です。

この便利なオブジェクト指向の特徴であるインヘリタンスも上位のクラスを一つしかもてないシングルインヘリタンスですのでマルチインヘリタンスに比べると不便と言えば不便です。

シングルインヘリタンスと聞きますと上位から下位まで一本の線でしかつながっていない直線構造の様に考えますが、シングルと言っても直系の上位クラスが一つと言う事で直系の下位クラスは任意の個数を持つことができます。

しかしインスタンスのラインが１本と考えるとわかりやすいので系図をもって説明していきます。

　　 車
　　　｜
　　　｜　←トランクリッドを取る
　　　↓
　　ピックアップ・トラック
　　　｜
　　　｜　←荷台にルーフをつける
　　　↓
　　バン・ワゴン
　　　｜
　　　｜　←四輪駆動にする
　　　↓
　　ＲＶ
　　　｜
　　　｜　←ボディ鋼板を厚くする
　　　↓
　　軽装甲車

と、強引に現実の製品系列を無視していますがその意図は理解していただけると思います、すべての製品が自動車と言う機能を継承していますし途中で追加された機能も下位の製品では継承しています。

先のオーバーライドをこの図式で説明しますと「荷台にルーフをつける」で金属製ではなくキャンバス地にすると言った感じで機能を付け替える（オーバーライド）ことで感じがつかめるはずです。

インヘリタンスにおける直系上位は一つだけですが直系下位は任意の個数定義できますのでこの自動車系図を当てはめますと

上位
　　　　　　　　　　　　車
　　　　　　　　┌───┤
　ルーフを取る→｜　　　｜←トランクリッドを取る
　　　　　　　　↓　　　↓
　　　オープンカー　　ピックアップ・トラック
　　　　　　　　│　　　│
　　キャンバス→｜　　　｜←荷台にルーフをつける
　　　　ルーフ　｜　　　↓
　　　　　　　　｜　　バン・ワゴン
　　　四輪駆動→｜　　　｜
　　　　　　　　↓　　　｜←四輪駆動にする
　　　　　　ジープ　　　↓
　　　　　　　　｜　　ＲＶ
　スクリューを→｜　　　｜←ボディ鋼板を厚くする
　　　　つける　｜　　　├−−−┐
　　　　　　　　↓　　　｜　　　｜←砲をつける
　　　水陸両用車　　　　↓　　　｜←キャタピラに変える
　　　　　　　　　　　軽装甲車　｜
　　　　　　　　　　　　　　　　｜
　　　　　　　　　　　　　　　　↓
ジープは登録商標です　　　　　　戦車

と言ったとこでしょうか、各名称は適当につけていることと下位の枝分かれが２つだけですが単なる紙面の都合だけですとお断りしておきます、しかし下へいくほど軍用の形態になっていくと言うのは不思議ですね車の機能から言ってスポーツカーと軍用車が両極の形と言う事なんでしょうか。

閑話休題

この例でも全ての下位は車と言う機能をインヘリタンスしていますことがおわかりと思います。しかしこの個々の製品は外見上見分けがつきますがオブジェクトの概念から言えばその以前の機能は表面的にまったくわからないと言うことに注意してください。（もっとも最近の車は外見だけでは区別がつかないものが多くなっていますけど）

さらに多重継承としての概念が有ります、いままではすべて上からの継承は一つだけてしたが、例えばラジオカセットは別の観点から見るとラジオにカセットテープという二つの機能が継承され合体してできたものでラジオにテープレコーダーが付属したのではなく両方の機能が融和してできたものとみなす事ができます。

この例からも分かるとおり複数のクラスからデータやメソッド等を継承していることを「多重継承」と言いますが単なる言葉としておぼえておいてくださるだけでそれ以上は初級入門者には必要ないでしょう。

なぜなら多重継承を系図化すると

　Ｎｏ１−−−−−−−
　　｜　　　　　　　　｜
　　｜　　　　　　　　｜
　Ｎｏ２　　　　　　Ｎｏ３−−−−−−−
　　｜　　　　　　　　｜　　　　　　　　｜
　　｜　　　　　　　　｜　　　　　　　　｜
　Ｎｏ４　　　　　　Ｎｏ５　　　　　　Ｎｏ６
　　｜　　　　　　　　　　　　　　　　　｜
　　｜　　　　　　　　　　　　　　　　　｜
　　　−−−−−−−Ｎｏ７ーーーーーーＮｏ８
　　　　　　　　　　　｜
　　　　　　　　　　　｜

と言う感じになります、この系図でNo8に対する直接の親（Base）はNo7とNo6になり両方のオブジェクトやメソッドなどがぶつかる場合がでてきます。

この様な場合に「なにをさせようとしているのか」「両方をさせようとしているのか」「両方の時どちらを優先させるか」などと言う問題が出てきます。

これらは非常に高度のテクニックと細心の注意が必要ですから初級入門者には難題となりますので言葉としてとどのようなものかだけを覚えておけばよいでしょう。

多態性

オブジェクト指向プログラムにおける最大の難所である多態性ですが、この拙文はオブジェクト指向プログラムの勉強ではなく「オブジェクト全体」の入門解説ですから深くは触れませんがある程度の事を知っていても損はないので軽く触れます。

多態性というまったくもって意味の通らない日本語のもとはポリモルフィズムと言う言葉でポリモルフィズムとはPolymorphismと書きギリシャ語のpoly＝多くの、とplymorphism＝意味の要素、が合わさってできた言葉で「同名異型」という意味です。

そして導きだされることは「異なる型に対して同名の操作を行う事ができる」となり逆の書き方をすると「異なる機能を持つ物が同じ名前をもつことができる」と言う事になります。

先のインヘリタンスでもメソッドで同じ名前を定義するオーバーライドということができましたしオーバーライドと同一の様ですがまったく違っております。

さきでのオーバーライドでは同じ名前を使うことにより上位クラスの機能は下位クラスの機能に書き換えられてしまいます、しかしポリモルフィズムにおいては同一の名前をつけても機能が書き換えられません。

　「同一の名前でも機能が違う」

と言うことです

このことがどんなメリットがあるかと言うことは初級程度のプログラムではなかなか難しいところがありますが、構造化プログラムの特質である、ルーチンの部品化を突き詰めていく結果に出てきたのでは思われます。

すなわちプログラム上では必要となる知識ではあるが、単純にオブジェクト指向の入門と言う立場では特に必要がある言葉だろうか、と言う結論がでてしまう身も蓋もないことになります。

初級におけるポリモルフィズムの意味は

上位のクラスから下位のクラスまで一つの動作に同じ名前をつけてそれぞれのクラス内では別々の動作をさせる、そしてポリモルフィズムを実現するのがバーチャルメソッドで、仮想的に記述することによりそれらのメソッドの参照先をコンパイル時に決めず実行時に決めるとなります。

簡潔に言えばポリモルフィズムが「戦略」でバーチャルメソッドが「戦術」と言えます。