雑談：今時のC++教育を考える

　今からC++を学習する人は、どのように教えたらいいのだろう。そして、どこまで教えたらいいのだろうか？C++を教えて欲しいと言われた時、よく私はこの課題を考えます。C#やJavaなどと比べて、C++を教えるのは難しいと感じています。
　その原因はC++が、Cとの互換性を維持しつつ（C99とはないけどね）、マルチパラダイム言語化しているからです。C#やJavaといった後続言語と比べて、その辺がごちゃごちゃしている印象がぬぐいきれません。それがチャームポイントなのですが、教えるとならば話しは別。やり辛いです。
　ひとまず私は、オブジェクト指向の側面から教えるのがよいと考えています。C++の目的はオブジェクト指向だから、言語設計思想からズレていないと思います。あとは、テンプレートは是非教えたいです。テンプレートはC++の大きな魅力。テンプレート無くしてC++と呼べません！
　しかし、テンプレートはオブジェクト指向以上に教えにくいです。オブジェクト指向は方法論がありますが、メタテンプレートプログラミングや、ジェネリックなテンプレートプログラミングに方法論はありません。テンプレートは、STLや標準ライブラリのソースを読むのが、一番の訓練方法です。自分で実装してみれば、テンプレートプログラミングがよく分かります。でもこれは、万人にお勧めできる方法ではありません。私は未だにテンプレートを上手く教えられません。
　それに加えて、スライスなどのバイナリな落とし穴がC++にはあります。C++の魅力は、こういったダーティな部分にあると思うのですが、それを伝えるのは難しいです。今時の人は、初めての言語がJavaとかC#の人がいるから、そんな安全な言語を知っている人にC++の危険な魅力を言っても「面倒」だと言われそうです。アセンブラとC言語をやった事ない人に、C++の魅力を伝えるのは難しいです。
　C言語やアセンブラをやった人ならば、C++の魅力が分かると思うのですが、偉大なるまつもとゆきひろ氏はC言語を使い続けると言っているし、スーパーハッカーのリーナス氏もC++が好きでないという噂を聞いた事があります。
　ということは、Cやアセンブラをやって、今時の高級言語にない機能が好きな人だけC++を好きになるのかもしれませんね。といっても、最近の.NET言語も教えにくいかもしれません。バージョン1からしている人にとっては普通の事でも、今から学習をする人には敷居が高くなっているかもしれません。どんどんマルチパラダイム化しているからLINQとかラムダ式とかわかるかな？
　もしかしたらC++に限らず、どの言語でも今から学ぶ人は大変かもしれません。そういえば、F#も教えにくそうです。私はプログラミングF# と仕様書で分かりましたが、初心者にはきついかもしれない。F#は初心者にどう見えているのかな？

VC++雑談ープロセッサアフィニティとOpenMP実行ライブラリの不和？？？

今日OpenMPで遊んでいたら不思議な出来事に遭遇したピヨ。
今回はそれをお伝えするピヨ。
OpenMPには、呼び出された時点でプログラムが利用可能なプロセッサ数を返す実行時ライブラリomp_get_num_procsが規定されているピヨ。この関数の説明を読んだボクは一つの疑問が脳裏に浮かんだピヨ。
じゃあ、現在使用可能なCPUという事は、ハードアフィニティを使って、そのプログラムで利用可能なCPUを一つに制限すれば、関数の戻り値が1になるのかなって。
という事で、VC++2008で実際に試したピョッ♪


#include <stdio.h> #include <omp.h> #include <Windows.h> #include <process.h> int main(void) { printf( "現時点で利用可能なプロセッサ数は%dです。\n", 　　　　　　omp_get_num_procs() ); SetProcessAffinityMask( GetCurrentProcess(), 3 ); Sleep( 1000 ); //念のために待つ printf( "現時点で利用可能なプロセッサ数は%dです。\n", 　　　　　　omp_get_num_procs() ); printf( "\n" ); return 0; }

よし！これで2回目の実行は1を返すはずピヨ。・・・あれ？？2が返ってきたピヨォ。
現在利用可能って事は、1つのCPUにハードアフィニティしたプログラムは1を返さないとおかしいよね？
う～ん、ハードアフィニティを使用したら指定したCPUでのみ実行されるはずピヨ。
何か設定が間違っているのかもしれないから、試しにこのプログラムに無限ループを埋め込んでタスクマネージャでCPUの利用率を確認したけど、やっぱりCPU1でコードが実行されていたピヨ。という事は、確実にCPU1でしかプログラムが動かないって事だから・・・
この状況で使用できない関数に何の意味があるんだろう。どうやったら戻り値が変化するのかな？
この動作、将来のヴァージョンで見直されるといいな♪
もしかしたらこの関数、物理的に使用できるCPUの数を返すのかもしれないけど、アフィニティも考慮してくれなきゃ使いにくいピヨォ。
アフィニティも考慮して、現在利用可能なCPUが返ってきたら便利だと思うピヨ♪

STLをつつき彫る1－pairテンプレート。何時も仲良し♪

記念するべき第一弾はutilityに属するpairをつつき彫るピヨッ♪実装を見た方が話しが早いと思うから、早速実装をお見せするピヨ♪


//utility.hファイルへ実装 #ifndef UTILITY_ #define UTILITY_ #include <iosfwd> namespace indre { /----------------------------------------------------------------------- 二つの対となる値を保持する構造体。 -----------------------------------------------------------------------/ template< class T1, class T2 > struct pair { //フィールド typedef T1 first_type; typedef T2 second_type; //引数を持たないコンストラクタ pair() : first( T1( ) ), second( T2( ) ) { } //引数を持つコンストラクタ pair( const T1& V1, const T2& V2 ) : first( V1), second( V2 ) { } //テンプレートクラス template< class U1, class U2 > pair( const pair<U1, U2>& X ) : first( X.first ), second( X.second ) { } T1 first; T2 second; }; /----------------------------------------------------------------------- pairテンプレートの各種演算子。 -----------------------------------------------------------------------/ template< class T1, class T2 > inline bool operator == ( const pair< T1, T2 >& X, const pair< T1, T2 >& Y ) { return (X.first == Y.first && X.second == Y.second ); } template< class T1, class T2 > inline bool operator != ( const pair< T1, T2 >& X, const pair< T1, T2 >& Y ) { return ( ! ( X == Y ) ); } template< class T1, class T2 > inline bool operator < ( const pair< T1, T2 >& X, const pair< T1, T2 >& Y ) { return ( X.first < Y.first || ! ( Y.first < X.first ) && X.second < Y.second ) ; } }

うーん。本と同じになってしまったピヨォッ！
変えようと思ったんだけど、コードが少なすぎて変更できなかったorz
それは、さておき、例の本を読んでいない人は、演算子の定義が気になると思う。例えばここ、

return ( X.first < Y.first || ! ( Y.first < X.first ) && X.second < Y.second ) ;
一見すると不思議な実装だけど、STLの実装には無駄なんて無く、これにも意味があるピヨ。この様に一つの演算子のみを使用した方が効率がいいからなんだ。詳しい説明は難しいから今後日を改めてするピヨ♪
実装したら早速テストしよう！テストプログラムは、STLをつつく1－pairテンプレート。仲良く行こう♪の記事にあるサンプルを使ってね♪その際、//#define TEST のコメントを解除しよう。これでテストが行えるピヨ♪
今回はこれ以上何も囀る事がないからこれでおしまい。

バサバサバサバサバサバサバサバサバサバサバサバサバサバサバサバサバサバサバサバサバサバサ

STLをつつく1－pairテンプレート。仲良く行こう♪

今回はutilityに属するpairをつつくピヨ♪このテンプレートは、1つの組となる値を保持する構造体を提供するものピヨォ♪。例えば、IDと名前を保持する構造体をプログラムで使いたい場合や、誰と誰が恋人同士なのかを保持する構造体が欲しい時とかに使用するピヨ♪
前置きはこれぐらいにして、お楽しみのサンプルをお見せするピヨ♪


//#define TEST #include <assert.h> #include <iostream> #ifdef TEST #include "utility.h" using namespace indre; #else #include <utility> using namespace std; #endif //テスト用のPairクラス typedef pair< int, char > Pair_Foo; int main() { //引数を持たないコンストラクタのテスト Pair_Foo p1; assert ( p1.first == 0 ); assert ( p1.second == 0 ); std::cout << "引数を持たないコンストラクタの初期値は、first = " << p1.first << " second = " << p1.second << " です。\n"; //引数を持つコンストラクタのテスト int param1 = 0; char param2 = 'a'; Pair_Foo p2 = Pair_Foo ( param1, param2 ); assert ( p2.first == param1 ); assert ( p2.second == param2 ); std::cout << "引数を指定してコンストラクタを呼び出しました。\n" << "値はfirst = " << p2.first << " second = " << p2.second << " です。\n"; //演算子のテスト assert ( p1 != p2 ); std::cout << "p1とp2は等価ではありません。\n"; assert ( p1 < p2 ); std::cout << "p1はp2未満です。\n"; assert ( p1 <= p2 ); std::cout << "p1はp2以下です。\n"; assert ( p1 == p1 ); std::cout << "当たり前ですが、p1とp1は等価です。\n"; assert ( p2 > p1 ); std::cout << "p2はp1より超えています。\n"; assert ( p2 >= p1 ); std::cout << "p2はp1以上です。\n"; }

このサンプルを実行したら、utility::pairが比較も出来る便利な構造体を作ってくれるという事が分かるピヨ♪プログラミングをしていると、組で扱えたら便利だと思うオブジェクトが結構あるから便利だね♪えっ？何でアサートとかあるかって？それはねぇ、この記事がSTLをつつき彫るシリーズと連動しているからなんだピヨッ♪STLを実装したらテストが必要だから、そのテストを有効利用するためにこのシリーズを書く事にしたんだ。一石二鳥だね♪

STLをつつき彫る0.1－ライブラリ実装の心得1。衝動を抑えろ。

また、ドリィちゃん意味わからない題名を・・・
ドリィちゃん「だって、STLでは私の生き甲斐が満足な形で出来ないぃぃぃぃ。」
生き甲斐？・・・・テストだね。
ドリィちゃん「そうよ。STLではテストケースが無限に作れてしまうから、どこかで我慢しなくちゃならないのよぉぉ。あー全てのテストがしたという充実感が欲しいぃぃ」
それは仕方が無いピヨ。STLは無限に等しい数の型を適用できてしまうからね。でもまぁ、そんなに気にする事じゃないと思うけど・・・
ドリィちゃん「いや、気になるわぁ。ホワイトテストが実質不可能という事じゃない。重箱の隅までつついて、担当者を泣かすまでやるのがテストの醍醐味じゃないの！」
いやぁ・・・それは違うと思うピヨ。開発者を余り虐めないで。もちろんボクもね♪
ドリィちゃん「でも、全てのテストがカバーできたという区切りがないと、テスト目標がわからないじゃないの！そんなんじゃ、テストにならない。」
それはそうかもしれないピヨ。テストが甘いと、テストで使用した型以外を使用したらバグが発生するかもしれないし・・・
ドリィちゃん「そうなのよぉ。でもまぁ、仕方が無いから、汎用的な型の全メソッドをテストするぐらいで勘弁してあげるわ。」
勘弁って、そんなｗ・・・・はっ！STL実装でボクがテストされるんだよね！
ドリィちゃん「そうよ覚悟なさい。」
ひぇぇー。今から嫌な予感がするけど、とにかくSTLのテストは難しいよ。だからその点を踏まえて、STLの実装はテストコードとともに紹介するピヨ。 テストに関しては実際にコードを見せるしかないから今回はおしまい。じゃあねー。

STLをつつき彫る0－ライブラリ実装の心得0。汚されないように注意を払え。

このテーマの記事ではSTLを実装していくピヨ♪内容が内容だけに更新頻度は少ないと思うけど、気長に待ってね♪それにしてもこの題名なんだろう？まさか・・・
ドリィちゃん「私が考えたんだけど、それが何か？」
なっ何でも無いピヨォ
ドリィちゃん「ならいいわ。ライブラリにはよく_(アンダバー)　+　大文字　+　_(アンダバー) のマクロがある。それは何故？」
いきなり言われても・・・うーん。見やすいからかな？
ドリィちゃん「あれが見やすいと本気で思う？」
うっ。いや、まぁ、みにくいと思うけど、欧米の人は見やすいのかも。
ドリィちゃん「不正解。考えが、甘いぃぃ」
えっ違うの！orzえっと、うーん。ハッカー的好みじゃない？
ドリィちゃん「馬鹿。ハッカーは理由が無いものを好まないの！仕方が無いわねぇ。答えはマクロに汚されないようによ。」
うーん。意味がわからない・・・
ドリィちゃん「まったくぅ。それじゃあSTLは実装できないわ。わかりやすく言うと、野獣の群れに、私のように可憐な美女を放り込むということよ。」
えっ！・・・余計にわからないピヨ。ドリィちゃんだったら口で勝てるピヨォッ！
ドリィちゃん「帰るわよ。」
ごめんごめん。そりゃ危ないね。でっどういう意味？
ドリィちゃん「マクロはねぇ、範囲が無差別かつ広範囲だから上書きされる恐れがあるの。つまり、マクロ汚染の危険性があって事よ。」
なるピヨ。偶然にライブラリで使用しているマクロと同じ名前のマクロを定義されたら困るピヨか。でもそれならば、MAXPIYOというふうに語尾にPIYOを付加すればいいじゃない？
ドリィちゃん「・・・もっもし、ピーター・イーシャ・吉田・オスマンの開発チームがあったらどうするのよ。ライブラリは星の数程のプログラマが使うものだからそういうことに気をつけないといけないの！_から始まる名前はC++標準規格で使用しないということになっているから安全なのよ。」
何故、一人だけ日本人なの？・・・まぁ、それはいいとしても、ライブラリの作者は大変だね。
ドリィちゃん「そうよ、わかればいいのよ。でも可読性がとっっっっても落ちるから、この連載ではアンダーバーはつけないわ。」
それがいいピヨね♪みんな、この連載ではアンダーバーをつけないけど、実際にSTLを実装する際には、マクロ名は_ + 大文字 + _ にしよう。絶対だよ。
じゃあ、今回はおしまい。それじゃあボクは勉強会へいくよ。とぉー

バサバサバサバサバサバサバサバサバサバサバサバサバサバサバサバサバサバサバサバサバサバサ

C++を咥えて個別アルゴリズムをつつく3－マージソート。細かく砕いて並べるピヨ。

この記事は「 個別のアルゴリズムをつつく3－マージソート。一旦分割♪これマジだよぉ。 との連動企画ピヨ。詳しい説明はそちらを見てね。 そして、ボクの実装例を見る前に自分で実装を試みよう。
お待たせ♪それじゃつつくピヨ♪今回もアルゴリズムの考え方を伝えるために、効率を度外視して作ったピヨピヨ♪

#include 
using namespace std;

//保持するデータの最大数
static const int MAX = 10;

//マージソート
class SearchMan {
private:

//要素を交換する
static void Exchange( int values[], int destination, int source ) {
    int tmp = values[ destination ];
    values[ destination ] = values[ source ];
    values[ source ] = tmp;
}

//指定した範囲のソースをもとに、2個に分割を行う。
static void Divide( int* source, int start, int end, 
    int*& leftArray, int*& rightArray ) {

    //分割後のサイズを求める
    int length = start + end;
    int leftSize = length / 2;
    int rightSize = length - leftSize;

    //分割する
    leftArray = new int[ leftSize ];
    rightArray = new int[ rightSize ];

    //元の値をコピーする
    for ( int i = 0; i < leftSize; i++ ) 
	leftArray[ i ] = source[ i ];
    for ( int i = 0; i < rightSize; i++ ) 
	rightArray[ i ] = source[ i + leftSize ];
}
	
//2つの配列をソートして一つの場所へ出力する
static void Merge( int* leftArray, int leftSize,
	int* rightArray, int rightSize, int*& outArray ) {
		
    //各種変数を準備
    int leftIndex = 0;
    int rightIndex = 0;
    int outIndex = 0;
    outArray = new int[ leftSize + rightSize ];

    //左右を比較しながら出力
    while( leftIndex < leftSize && rightIndex < rightSize ) {
	//小さいほうを出力
	if ( leftArray[ leftIndex ] <= rightArray[ rightIndex ] ) {
		outArray[ outIndex ] = leftArray[ leftIndex ];
		leftIndex++;
	} else {
		outArray[ outIndex ] = rightArray[ rightIndex ] ;
		rightIndex++;
	}
	outIndex++;
    }

    //残りを出力
    if( leftIndex < leftSize ) {
	for( int i = leftIndex; i < leftSize; i++ ) {
		outArray[ outIndex ] = leftArray[ i ];
		outIndex++;
	}
    } else {
	for( int i = rightIndex; i < rightSize; i++ ) {
		outArray[ outIndex ] = rightArray[ i ];
		outIndex++;
	}
    }
    return;
}

public :

static void MergeSort( int*& source, int start, int end ) {

    //長さが1ならばこれ以上分割できないので何もしない
    int length = start + end;
    if ( length == 1 ) return;

    //長さが2の場合は交換だけして終わる
    if ( length == 2 ) {
	if ( source[ 0 ] > source[ 1 ] ) 
		Exchange( source, 0, 1 );
	return;
    }

    //半分に分割する
    int* leftArray = 0;
    int* rightArray = 0;
    int leftSize = length / 2;
    int rightSize = length - leftSize;
    Divide( source, start, end, leftArray, rightArray );

    //分割後の配列に対してマージソートを行う
    MergeSort(leftArray, 0, leftSize);
    MergeSort(rightArray, 0, rightSize );

    //ソート後の2つの配列を融合する
    int* outArray = 0;
    Merge( leftArray, leftSize, rightArray, rightSize, outArray );

    //結果を反映する
    source = outArray;

    //後始末
    delete leftArray;
    delete rightArray;
}

};

int main(void)
{
    int values[MAX] = { 9,3,5,6,2,8,7,0,1,4 };
    int* result = (int*)values;

    //整理前のデータを確認
    cout << "整列前のデータを表示します。" << endl;
    for(int i = 0; i < MAX; i++) cout << values[i] << '\t';
    cout << endl;

    //ソートする
    SearchMan::MergeSort( result, 0, MAX );

    //整理後のデータを確認
    cout << "整列後のデータを表示します。" << endl;
    for(int i = 0; i < MAX; i++) cout << result[i] << '\t';
    cout << endl;
    return 0;
}

C++を咥えて個別アルゴリズムをつつく2－基本挿入ソート。ちょっと右へよってよ！

この記事は「 個別のアルゴリズムをつつく2－挿入ソート。ちょっと右へ寄ってくださる？ 」 との連動企画ピヨ。詳しい説明はそちらを見てね。 そして、ボクの実装例を見る前に自分で実装を試みよう。
お待たせ♪それじゃつつくピヨ♪

#include 
using namespace std;

//保持するデータの最大数
static const int MAX = 10;

//基本挿入ソート
class SearchMan {
public:
    static void InsertSort(int target[MAX]) {
	for(int insertIndex = 1; insertIndex < MAX; insertIndex++) {
	    //挿入場所に当たるデータを退避
	    int tmp = target[ insertIndex ];
	    //移動する位置
	    int moveIndex = insertIndex -1;
	    //後ろから順番に横へずらしていく・・・
	    while( moveIndex >= 0 ) {
		//挿入位置決定！
		if ( tmp > target[ moveIndex ] ) break;
		//挿入するべき位置じゃないので横へずらす
	        target[ moveIndex + 1 ] = target[ moveIndex ];
	        //隣を調べる
	        moveIndex--;
	    }
	    //あるべき位置へデータを挿入する
	    target[ moveIndex + 1 ] = tmp; 
	}
    }
};

int main(void)
{
    int values[MAX] = { 9,3,5,6,2,8,7,0,1,4 };

    //整理前のデータを確認
    cout << "整列前のデータを表示します。" << endl;
    for(int i = 0; i < MAX; i++) cout << values[i] << '\t';
    cout << endl;

    //ソートする
    SearchMan::InsertSort( values );

    //整理後のデータを確認
    cout << "整列後のデータを表示します。" << endl;
    for(int i = 0; i < MAX; i++) cout << values[i] << '\t';
    cout << endl;
    return 0;
}

C++を咥えて個別アルゴリズムをつつく1－番兵法。必ずヒット♪

この記事は「 アルゴリズムの方法論をつつく3－番兵法。見張り番で効率UP。 」 との連動企画ピヨ。詳しい説明はそちらを見てね。 そして、ボクの実装例を見る前に自分で実装を試みよう。
お待たせ♪それじゃつつくピヨ♪

#include 
using namespace std;

//保持するデータの最大数
static const int MAX = 10;

//線形探索法で指定された値を探索する
//なお、戻り値がー1の場合は発見出来なかった事を示す。
class SearchMan {
public:
    static int LinearSearch(int target[ MAX + 1], int searchValue) {
        int index;
	//番兵をしのばす
	target[ MAX ] = searchValue;
	//逐次的に探す
	for( index = 0; target[ index ] != searchValue ; index++) {  }
	//見つかったの？それとも番兵？
	if ( index == MAX ) return -1; 
	return index;
    }
};

int main(void)
{
    int values[ MAX + 1 ] = { 9,3,5,6,2,8,7,0,1,4,0 };

    //整理前のデータを確認
    cout << "整列前のデータを表示します。" << endl;
    for(int i = 0; i < MAX; i++) cout << values[i] << '\t';
    cout << endl;

    //探索するデータを決定
    int searchValue = 0;
    cout << "検索する数値を0～9の範囲内で指定して下さい：";
    cin >> searchValue;
	
    //線形探索の結果を表示
    int index = SearchMan::LinearSearch(values, searchValue );
    if ( index == -1 ) {
	cout << "指定された値「" << searchValue << 
		"」は用意された配列内に存在しません。" << endl;
	return -1;
    }
    cout << "指定された値「" << searchValue << "」を" 
	<< ( index + 1 ) << "番目で発見しました！" << endl;
    return 0;
}

前の実装と見比べてみよう。逐次的に探すの部分がかなり効率的になっているピヨ。今回は件数が少ないからメリットが見えにくいけど、１００0万件とか大量のデータだったらパフォーマンスに差が出るピヨ。今回はこれでおしまい。次回お楽しみに！ ピッヨッピヨ。

C++を咥えて個別アルゴリズムをつつく0－線形探索法。まめな方法だね♪

この記事は「 アルゴリズムの方法論をつつく2－線形探索。仕方がない、逐一調べよう。」 との連動企画ピヨ。詳しい説明はそちらを見てね。 そして、ボクの実装例を見る前に自分で実装を試みよう。
お待たせ♪それじゃつつくピヨ♪

#include < iostream >
using namespace std;

//保持するデータの最大数
static const int MAX = 10;

//線形探索法で指定された値を探索する
//なお、戻り値がー1の場合は発見出来なかった事を示す。
class SearchMan {
public:
    static int LinearSearch(int target[MAX], int searchValue) {
        int index;
	//逐次的に探す
	for( index = 0; index < MAX; index++) {
		if( target[ index ] == searchValue ) {
			break;
		}
	}
	//見つかったの？それとも最後まで行っちゃったの？
	if ( index == MAX  ) 
		return -1; 
	return index;
    }
};

int main(void)
{
    int values[MAX] = { 9,3,5,6,2,8,7,0,1,4 };

    //整理前のデータを確認
    cout << "整列前のデータを表示します。" << endl;
    for(int i = 0; i < MAX; i++) cout << values[i] << '\t';
    cout << endl;

    //探索するデータを決定
    int searchValue = 0;
    cout << "検索する数値を0～9の範囲内で指定して下さい：";
    cin >> searchValue;
	
    //線形探索の結果を表示
    int index = SearchMan::LinearSearch(values, searchValue );
    if ( index == -1 ) {
	cout << "指定された値「" << searchValue << 
		"」は用意された配列内に存在しません。" << endl;
	return -1;
    }
    cout << "指定された値「" << searchValue << "」を" 
	<< ( index + 1 ) << "番目で発見しました！" << endl;
    return 0;
}
※間違いがあったので訂正しました。

どう？見てのとおり不器用なアルゴリズムだね。ソートしていないとデータが探しずらい事がよく分かるピヨね。みんな、整理整頓はマメにしておこう♪じゃ、バイ♪バイ♪