プログラミング所感 - 目次 次へ

97/11/11(月)

ここから、本題。ライブラリには3つの側面、「便利」、「融通」、「効率」がある。
これらは、それぞれ相反しているように見える。
その点、ＳＴＬは３つともいい線をいっていると思う。
欠点は、コンパイルが遅くなるのと、デバッグがしにくくなるところか。 標準といいながら、まだコンパイラでインターフェースが異なるのもいまいち。 できれば、vectorの範囲チェックも欲しい所だ。 （注：at でできるが、assert のようにコードを変えずにチェックしたり しなかったりを実現したい。）
また、listはvectorほど効率的でないようだ。 （基本のインターフェースをvectorで考えて、listはそれにあわせたという感じ。）
ライブラリが便利なのは当たり前だ。
しかし、Ｃ／Ｃ＋＋では、厳密な型チェックがされるので、融通の効くサブルーチン作成は難しい。 テンプレートを使えばこそ融通性が出てくる。（薄いラッパーですめば、一番理想的だ。） そもそも、Ｃ／Ｃ＋＋では、コンテナのサポートが貧弱すぎる。 言語でサポートしているのは配列だけだ。 （ここで、コンテナといっているのは、配列やリストなど。）
Ｃ＋＋でコンテナを抽象化しようとしたら、コンテンツをポインタにするよりない。 これからのプログラミング言語では、コンテナをよりサポートすることが必須であろう。 Ｃ＋＋はＳＴＬでＣよりは進んだが、まだまだである。 Ｌｉｓｐ並みに型フリーならばよいかどうかはわからないが。

バグの記録の方はさっぱり進んでいない。バグが出ているのは出ているのだが。

97/11/14(金)

#include <string>
using namespace std;
int main()
{
	string b1,b2;
	b1 = "1234567890123456789012345678901234567890";
	b2 = b1;
	b1 = "ok";
	return 0;
}

98/7/24(金)

#include <iostream>
#include <deque>

using namespace std;

struct A {
  char s[256];
};

int main()
{
  int i,j;
  deque<A> d;
  deque<A>::iterator it;

  for (i=0;i<100;++i) {
    d.push_back(A());
    it = d.begin();
    for (j=0;j<d.size();++j) ++it;
    if (it != d.end())
      cout << d.size() << " not match!\n";
  }
  return 0;
}

98/7/27(月)

int NumOfBits(__int64 i)
{
	i = (i & 0x5555555555555555) + (i >> 1 & 0x5555555555555555);
	i = (i & 0x3333333333333333) + (i >> 2 & 0x3333333333333333);
	i = ((i >> 4) + i) & 0x0f0f0f0f0f0f0f0f;
	long j = (long)(i + (i >> 32));
	j += j >> 16;
	return (int)(j + (j >> 8)) & 0xff;
}

98/7/28(月)

res = func();

高速化は表引きにしたら、昨日のやつの２、３倍速くなった。 表は１バイト分（＝２５６個）持った。

ちょっと気づいたこと。
普通、for 文とか static 変数があると、inline 展開されないが、 VCではされてしまう。（便利ではあるが）
あと、MMX Pentium でPentium Pro の指定をしたら逆に遅くなった。
さらに、最適化でカスタマイズを選んで、最大の最適化を選んだのに 逆に遅くなった。

98/8/5(水)

	for (i=0;i<100000000;++i)
		func();

	func();
	for (i=0;i<100000000;++i);

	volatile int i,v;
	for (i=0;i<100000000;++i)
		v = func();

	tmp = func();
	for (i=0;i<100000000;++i)
		v = tmp;

実際、

	k = a[i]+a[j]+a[k];  (A)
	k = 1;               (B)

ちなみに、アセンブラを吐き出させるには、 コンパイラオプションで指定すればよい。
（VC++では、「プログラマーズガイド」の 「コンパイルとリンク」の「詳細」の 「コンパイラリファレンス」に出ている。）
といいながら、実はデバッガで見ている。
VC++のアセンブラはMASMというやつらしいが、 見るとなんとなく動きはわかる。
（もっとも、昔アセンブラを結構やっていたせい もあるだろう。）

98/8/6(木)

ところで、次の２つはどちらが、実行速度が速いか？

• ケース A

      for (it=v.begin();it!=v.end();it++)
          *it = i;
  

• ケース B

      for (j=0;j<100;++j)
          v[j] = i;
  

ケース A

00401057 mov edx,dword ptr [esp+8] : edx = i 0040105B mov dword ptr [eax],edx : *it = edx 0040105D add eax,4 : it += 4 00401060 cmp eax,esi : ? it , v.end() 00401062 jne 00401057 : if !=0 goto

ケース B

0040105C mov edx,dword ptr [esp+10h] : edx = i 00401060 mov ecx,dword ptr [esp+0Ch] : ecx = j 00401064 mov dword ptr [esi+ecx*4],edx : v[ecx] = edx 00401067 mov edx,dword ptr [esp+0Ch] : edx = j 0040106B inc edx : ++edx 0040106C mov dword ptr [esp+0Ch],edx : j = edx 00401070 cmp dword ptr [esp+0Ch],edi : ? j , 100 00401074 jl 0040105C : if < goto

ケース B で無駄な代入が見られるが、しょうがないのだろう。
結局、配列は添字よりポインタの方が速いようである。

(9/13/99追記：添字とポインタのどちらが速いかは一概に言えないようである。 実際、v[j] = j を int* p=v.begin();(ループ外) *(p+j) = i; に変えると、 スピードは変らない。ちなみに、v[j]の定義は、*(v.begin()+j) であり、 v.begin() は、v._First である。何でスピードが変るかは不明。)

98/8/13(木)

98/8/14(金)

char* strcpy(char *dst, const char *src)
{
    while (*dst++ = *src++) ;
}

いろいろ、書いてみてアセンブラがどうなっているか比較してみた。 コンパイラはVC++5 である。 （最近、アセンブラに凝ってしまった。）

Case 1:      while (*dst++ = *src++) ;
Case 2:      while (*s) *s++ = *t++;
             *s = 0;
Case 3:      do *s = *t++; while (*s++);
Case 4:      while (1) {*s = *t++; if (*s++) break;}

Case 1:
00401000   mov         edx,dword ptr [esp+8]   : edx = t
00401004   mov         ecx,dword ptr [esp+4]   : ecx = s
00401008   inc         ecx                     : ++ecx
00401009   mov         al,byte ptr [edx]       : al = *edx
0040100B   inc         edx                     : ++edx
0040100C   mov         byte ptr [ecx-1],al     : *(ecx-1) = al
0040100F   test        al,al                   : ? al
00401011   je          0040101D                : if ==0 goto
00401013   mov         al,byte ptr [edx]       : al = *edx
00401015   mov         byte ptr [ecx],al       : *ecx = al
00401017   inc         ecx                     : ++ecx
00401018   inc         edx                     : ++edx
00401019   test        al,al                   : ? al
0040101B   jne         00401013                : if !=0 goto
0040101D   ret

Case 2:
00401000   mov         eax,dword ptr [esp+4]   : eax = s
00401004   cmp         byte ptr [eax],0        : ? *eax,0
00401007   je          0040101A                : if ==0 goto
00401009   mov         ecx,dword ptr [esp+8]   : ecx = t
0040100D   mov         dl,byte ptr [ecx]       : dl = *ecx
0040100F   mov         byte ptr [eax],dl       : *eax = dl
00401011   mov         dl,byte ptr [eax+1]     : dl = *(eax+1)
00401014   inc         eax                     : ++eax
00401015   inc         ecx                     : ++ecx
00401016   test        dl,dl                   : ? dl
00401018   jne         0040100D                : if !=0 goto
0040101A   mov         byte ptr [eax],0        : *eax = 0
0040101D   ret

Case 3: 及び Case 4:
00401000   mov         ecx,dword ptr [esp+8]   : ecx = t
00401004   mov         eax,dword ptr [esp+4]   : eax = s
00401008   mov         dl,byte ptr [ecx]       : dl = *ecx
0040100A   inc         ecx                     : ++ecx
0040100B   mov         byte ptr [eax],dl       : *eax = dl
0040100D   inc         eax                     : ++eax
0040100E   test        dl,dl                   : ? dl
00401010   jne         00401008                : if !=0 goto
00401012   ret

簡単に言えば、一番すっきりしているのは、Case 3と4 となっている。 Case 1は、ちょっと余計なものがあるが、効率は Case 3と変わらない。 Case 2は、効率が悪い。という所である。

でも、素直に書いたら、Case 2だよな。Case 1とか3とか4 は、あまり書かないと思う。

98/8/17(月)

#pragma warning(disable:4786)

pragma により汎用的なプログラミングが 可能になっている。
Simple & Flexible のよい例といってもよいかもしれない。 それより、VC の実装者に言いたいのは、
「255文字を超えるようなクラス名なんか作るなよ」
ということである。
（解説：最初に示した pragma は、クラス名が255文字を 超えても warning を出さないように指示するものである。 map を使うと必ず255文字を超える。）（注：そうとも限らないようだ。）

STL のエラーメッセージは判りにくいものが多いが、 最近は慣れつつある。コツをお教えしよう。
「正しく書く」
あるいは、少しづつ書いていってコンパイルしていけば、 間違ったことを書いたときに、エラーが出るから分かるであろう。 STL については、C++OnePoint に多少説明を書いた。

(9/13/99追記：VC++6から上記の pragma はヘッダの前に書かないと 効果がないので注意して欲しい。)

98/8/24(月)

ZDnet ニュースの MS のソース利用者狩りという記事によると、 MS の開発しているアプリの中には、他のベンダに公開していない API を利用しているそうだ。なんとも人を馬鹿にしている話だ。 いくら大会社とはいえ、信用なんかできるものではない。 （もっとも、そのうち、誰かに全APIを暴露されちゃうかもね。）

もっと腹が立つのは、Javaに対しても独自機能を隠していれようと していることである。
言いたいことはいろいろあるが、とりあえず、「MS はJavaを使うな！」 Visula J++ を使うのは皆さんやめましょう。 （もし使っている人がいたら、私は品性を疑う。）

98/8/31(月)

さて、

    const n = 10;
    int a[n];

    int   i = 10;
    const n = i;
    int a[n];

10/19の話も参照。

98/9/4(金)

まず、１つめ。
ソートすると結果がおかしい。さんざん調べてやっと分かった。 （数字が左詰で表示されている時点でおかしいことに 気づけばよかった。）
表示形式を「標準」にすると、右詰と左詰に別れるのだ。つまり、 数字と文字に認識されているものが混じっていることになる。 これでは、ソートがおかしくなっていても不思議ではない。 客から貰ったデータなので、何故そうなっているのかは不明である。 とにかく、１列追加し、おかしい所を「=value(...)」でコピーし、 さらに、それをコピーして「形式を選択して貼付け」で値のみにして ペーストして一件落着。ちゃんとソートできるようになった。

もう１つは、同じデータをCSVにして保存すると、 そのファイルが開けないというものだ。

原因は、適当なSYLKファイルを作成して、テキストエディタで見てみれば分かる。 最初が、「ID;」で始まっているのだ。つまり、Excelは「ID」で始まっていると SYLKだと思うのだ。お馬鹿な仕様としかいいようがない。

98/9/7(月)

    class A {
        int a;
    };

もう１つ混乱しやすいことがある。入れ子クラスでは、アクセス指定をクラス名と クラス内のメンバ（及びメンバ関数）に設定できる。
このとき、クラス名を非公開にすれば、メンバが公開であってもアクセスできない と思うのは間違いである。（このような勘違いをしているライブラリを見かけたことがある。） 例えば、

    class A {
        struct X { void Func(){} };
        X	m_x;
    public:
        X* GetX(){return &m_x;}
    };

    A  a;
    a.GetX()->Func();

98/9/16(水)

98/9/19(土)

小さいプログラムでは、オブジェクト指向の方が効率が悪い。何故なら、 オブジェクト指向風に書くとコードが1.5倍から2倍ぐらいに増えるからだ。
オブジェクト指向が真価を発揮するのは、大きなプログラムだ。 何故なら、問題を小さく切り分けて考えやすくできるからである。 この問題対象を切り分けることが大事なのだ。 適切に切り分けられたなら、問題は抽象的に扱うことができる。 抽象的に扱うことによって、見通しがよくなる。

デザインパターンは切り分ける場所を示し、その名前を与えるものである。 つまり、プログラミングテクニックではなく、切り分けかたのサンプル集 なのである。（唯一、テクニックに近いものは、Decorator だと思うが、 他にもあるかも。）

オブジェクト指向に関する私の助言はこうだ。

• まず、動くものを作れ。
• 再利用しやすくしろ。

98/9/21(月)

    grep "^[P|p]ro" /usr/dict/words | wc

それはともかく、ソフト業界では、プログラマーといったら詳細設計書を元に プログラムを書くだけの人のことを指したりする。この作業は、それほど 面白いものでもなく、難しいものでもない。
プログラミングの面白さは、設計する所にあるからだ。 （といっても、プログラマーが設計も担当することが多いのも事実である。） プログラミングだけでなく、上流工程の作業もする職種をSE（システム・エンジニア） といったりもするが、呼び方が変わってもやっていることはたいして違わないと思う。

プログラマには向き・不向きがある。これは、プログラミングが好きか嫌いか とかなり相関がある。（好きならば上達していくはずだからだ。） 好きなだけでなく、論理的思考ができなければいけない。 （これができないと、プログラマとしてやって行くのはつらいと思う。） あと必要な素質は、好奇心旺盛なことだと思う。 コンピュータの業界は、次々と新技術が登場する。いつまでも古い技術で やっていたら、誰にも相手にされなくなる可能性が高い。
もっとも、変わらない技術もある筈だ。それは、しっかりと身につけた方がよいだろう。 （例えば、「プログラミング書法」とかかな。）

98/10/5(月)

（もし、私のプログラムが math.h の sin を使っていて、あなたのプログラムが、 同じく sin を使っているからといって、あなたが私のプログラムを必要になったら？）

これは、MS の陰謀としか言えない。私は、このために VC++5 を少なくとも3回は インストールするはめになった。全く、何とかして欲しいね。

98/10/6(火)

    refer_ptr<A>	p(new A(123)),q = p;
    p = refer_ptr<A>(new A(789));

    array_ptr<char>	p(new char[10]);
    delete p;	// 内部のポインタに対しては、delete[] が呼ばれる

    auto_ptr<array_ptr<char> >	p(array_ptr<char>(new char[10]));
    ... // p を使用
    // ブロックを抜けると自動的に delete[] が呼ばれる

98/10/13(火)

char* GetCSV(char** pBuf)
{
	char	*p = *pBuf,*q = p;
	if (!p) return p;
	if (*p == '"') {
		*p++ = 0;
		do ++q; while (*q && *q != '"');
		if (*q == '"') *q++ = 0;
	}
	if ((*pBuf = strchr(q,',')) != 0) *(*pBuf)++ = 0;
	return p;
}

98/10/19(月)

例えば、8/31 のconst の話では、VC++ では怒られるコードが g++ では平気だったりする。他にも、

    struct A {
        static i = 1;
    };

98/10/23(金)

    while (true) {
        if (*p == ' ') ++p;
        else if (!strncmp(p,"　",2)) p += 2;
        else break;
    }

    while (*p == ' ' || *p == '　') ++p;

    while (*p == ' ' || !strncmp(p,"　",2) && ++p) ++p;

     while (*p && *p != ' ' && *p != "　"[0]) ++p;

     while (*p && *p != ' ' && strncmp(p,"　",2)) ++p;

追記：DOS od を見てて何か変だと思ったら、バイトオーダが UNIX と逆だからだった。
2000/4/5の話も参照。

98/10/28(水)

• dynamic_cast
• static_cast
• const_cast
• reinterpret_cast

#include <cstdio>

struct A {
	int i;
	A(int i0) : i(i0){}
};
struct B {
	int j;
	B(int j0) : j(j0){}};
struct C : A,B {
	C(int i0,int j0) : A(i0),B(j0){}
};

int main()
{
	B	b(-1);
	C	c1(1,2);
	static_cast<B&>(c1) = b;
	printf("%d %d\n",c1.i,c1.j);
	C	c2(1,2);
	reinterpret_cast<B&>(c2) = b;
	printf("%d %d\n",c2.i,c2.j);
	return 0;
}

11/9の話も参照。

98/11/5(木)

#include <cstdio>
struct A {bool b;};
int main()
{
	bool	a = A().b, b = true;
	if (a && b) printf("a && b\n");
	if (a &  b) printf("a &  b\n");
	return 0;
}

ついでに言えば、int から bool への暗黙の変換もない方が言語としては 親切だと思う。（そして、if 文は bool しか受け付けなくするわけだ。）
P.S. Java ではそういう風になっている。確かにこの方がよい。

(9/13/99追記：上の例は、未定義値を使用しているので、例として相応しくない。 また、上記の件も再現性がないので、バグかどうかは分からない。)

98/11/6(金)

98/11/8(日)

    1      2         o
   2 3    5 3       o o
         6 1 4     o o o
                  o o o o
                 o o o o o

#include <cstdio>
#include <algorithm>
using namespace std;

void Check(int n,bool chk[],int res[],int pos,int i,int j)
{
	int		k,a,b,c;
	if (pos == n) {
		for (k=0;k<n;++k) printf("%d ",res[k]);
		printf("\n");
		return;
	}
	if (j == 0) {
		if (++j > i) ++i,j=0;
		for (k=1;k<=n;++k) if (chk[k]) {
			chk[k] = false;
			res[pos] = k;
			Check(n,chk,res,pos+1,i,j);
			chk[k] = true;
		}
	} else {
		a = res[pos-1];
		b = res[pos-i-1];
		if (++j > i) ++i,j=0;
		k = a+b;
		for (c=0;c<2;++c) {
			if (chk[k] && k >= 1 && k <= n) {
				chk[k] = false;
				res[pos] = k;
				Check(n,chk,res,pos+1,i,j);
				chk[k] = true;
			}
			k = a-b;
		}
	}
}
int main()
{
	const	max = 100;
	int		res[max], n = 15;
	bool	chk[max+1];
	fill(chk,chk+max+1,true);
	Check(n,chk,res,0,0,0);
	return 0;
}

    「組合せをしらみつぶしに探す場合でも、うまくやれば早くできる」

98/11/9(月)

    *(B*)&c1 = b;          // または (B&)c1 = b;
    *(B*)(void*)&c2 = b;

98/11/12(木)

    iterator と const_iterator

では、const 属性が付いたときの振舞いはどのようになるだろうか。 実験してみよう。

    Any        admy;
    const Any  cdmy;
    Any        a = cdmy;
    const Any  c = admy;
    Any        aa(cdmy);
    const Any  cc(admy);
    a = c;
    c = a;                   // NG
    Any*       padmy;
    const Any* pcdmy;
    Any*       pa = pcdmy;   // NG
    const Any* pc = padmy;
    pa = pc;                 // NG
    pc = pa;

class Any;
class const_Any {
    void operator=(const Any&);  // 宣言のみ
public:
    // const メンバ関数
};
class Any : public const_Any {
public:
    Any(){}
    Any(const const_Any& c) : const_Any(c) {}
    // 非const メンバ関数
    // 必要なら const メンバ関数を非const でオーバロードする
};

注意すべき所

• メンバの増減はない。（sizeof(Any) == sizeof(const_Any)）
• Any::Any(const const_Any&) に explicit は付けてはいけない。
• Any::Any(const const_Any&) を書いたため Any::Any() が必要になっている。
• コメント中のオーバロードはオーバライドの誤りではない。 オーバロードすれば、Any から、const と 非const と両方呼べるのだ。

11/16の話も参照。

98/11/13(金)

    for (int i=0;i<n;++i) {
        ...
    }
    // ここで i は使える？

    #define for if (false) ; else for

但し、私ならこんなマクロを使うよりは、for の中で 宣言しないようにするだろう。

98/11/16(月)

でも、何故、オーバロード（多重定義）にならないのだろう。不思議だ。

3/3の話も参照。

98/12/22(火)

    if (int i = func()) {
        // ...
    }

目次 次へ