ソースコード

#include <iostream>
using namespace std;

#include <stdio.h>
#include <pthread.h>

#define BUFFER_NUM 100
#define WAIT_NUM 1000000
#define LOOP_NUM 100

class HandleData {
public:
  HandleData()
  : index_(0), channel_array_len_(sizeof(channel_array_)/sizeof(channel_array_[0])), num_data_(0) {
    access_lock_ = PTHREAD_MUTEX_INITIALIZER;
    access_threshold_ = PTHREAD_COND_INITIALIZER;
  }

  // データの追加
  void putData(int n) {
    pthread_mutex_lock(&access_lock_); // スレッドにロックをかける
    while (index_ >= channel_array_len_) {
      printf("putData(): waitn");
      pthread_cond_wait(&access_threshold_, &access_lock_);
      // このスレッドを一時停止しロックを解除する（getData側のpthread_cond_signalが呼ばれるまで）
    }
    int i = index_;
    channel_array_[index_++] = n; // スレッドセーフなデータ格納
    printf("put: %2d in channel_array_[%2d]n", n, i);
    pthread_cond_signal(&access_threshold_);
    pthread_mutex_unlock(&access_lock_); // スレッドのロックを解除
  }

  // データの取得
  int getData() {
    pthread_mutex_lock(&access_lock_);
    while (index_ <= 0) {
      printf("getData(): waitn");
      pthread_cond_wait(&access_threshold_, &access_lock_);
      // このスレッドを一時停止しロックを解除する（putData側のpthread_cond_signalが呼ばれるまで）
    }
    num_data_ = channel_array_[--index_]; // スレッドセーフなデータ取得
    printf("get: %2d in channel_array_[%2d]n", num_data_, index_);
    pthread_cond_signal(&access_threshold_);
    pthread_mutex_unlock(&access_lock_);
    return num_data_;
  }

  // データを格納する関数(スレッド)
  static void *runPut(void *hd) {
    int wait_num = WAIT_NUM;
    HandleData *phd = reinterpret_cast<handleData*>(hd);
    for (int i = 0; i < LOOP_NUM; i++) {
      phd->putData(i);
      while (--wait_num); // 空回しで時間稼ぎ
      wait_num = WAIT_NUM;
    }
    return NULL;
  }

  // データを取得する関数(スレッド)
  static void *runGet(void *hd) {
    HandleData *phd = reinterpret_cast<handleData*>(hd);
    for (int i = 0; i < LOOP_NUM; i++) {
      phd->getData();
    }
    return NULL;
  }

private:
  pthread_mutex_t access_lock_; // 排他制御を行う変数(lock, unlock)
  pthread_cond_t access_threshold_; // 状態変数(waitしてlockを外す用途)
  volatile int index_;
  int channel_array_[BUFFER_NUM]; // putData()、getData()からアクセスされる変数
  const int channel_array_len_;
  int num_data_;
};

int main()
{
  pthread_t thr_put;
  pthread_t thr_get;
  HandleData hd;
  // スレッドの生成(走らせるのはstaticメンバ関数)
  pthread_create(&thr_put, NULL, HandleData::runPut, reinterpret_cast<void*>(&hd));
  pthread_create(&thr_get, NULL, HandleData::runGet, reinterpret_cast<void*>(&hd));

  pthread_join(thr_put, NULL);
  pthread_join(thr_get, NULL);

  return 0;
}

あまりこういった書き方はしないのだけれど。

実行結果の一例

put:  0 in channel_array_[ 0]
put:  1 in channel_array_[ 1]
put:  2 in channel_array_[ 2]
put:  3 in channel_array_[ 3]
get:  3 in channel_array_[ 3]
get:  2 in channel_array_[ 2]
＜中略＞
put: 96 in channel_array_[ 0]
get: 96 in channel_array_[ 0]
getData(): wait
put: 97 in channel_array_[ 0]
get: 97 in channel_array_[ 0]
getData(): wait
put: 98 in channel_array_[ 0]
get: 98 in channel_array_[ 0]
getData(): wait
put: 99 in channel_array_[ 0]
get: 99 in channel_array_[ 0]

pthreadで相互排他を行う際の注意点

boostのmutex::scoped_lockクラスであればデストラクタにロックの解除を任せられるので管理が楽ですが、pthreadでは「ロックする」、「ロック解除」の2ステップを必ず書かなければなりません。なのでロック中に予期せぬ例外やエラーの為関数などのスコープを脱する際もpthread_mutex_unlock()をし忘れていないか等の注意が必要です。

関連すると思われる記事：

• C++, boost::thread : スレッドの同期と排他制御 – mutex、conditionクラス
• C++, boost::thread : スレッドグループの生成と実行
• C++, boost::thread : スレッドの生成と実行
• java.io.StreamCorruptedExceptionが発生した原因とその解決策の一例
• Note of the Day – 2009-03-22

C++, pthread: スレッドの同期と排他制御 – MutexとCondition Variable is a post from: Yukun's Blog

mutex クラスの使い方

スレッドの排他制御を実現できます。具体的な使い方は、mutexインスタンスをmutex::scoped_lockクラスのコンストラクタの引数に指定し、そのインスタンスを取得することでロックをかけられます。あるスレッドが上の処理を以ってmutexインスタンスにロックをかけた場合、その他のスレッドは再度同一のmutexインスタンスにロックをかけられないようになっており、その他のスレッドはscoped_lockのコンストラクタ途中で待たされます。

mutexインスタンスのロック解除は、ロックをかけたスレッドがscoped_lockインスタンスのデストラクタを実行することで完了します。

condition クラスの使い方

次に、複数のスレッドを同期させる処理について。例えば、あるスレッドが排他的にある変数にアクセスしようとするが、その前にif文を用いて「Wait! そのアクセスちょっと待った！しばらく他のスレッドの処理を待て！」みたいな処理を行いたい場合。そのスレッドは既にmutex変数でロックを取得していますが、「待ち」に入る際はロックを解除する必要があります。

上述のような処理を実現するのがconditionクラスです。メンバ関数のwait()に引数にmutexインスタンスを指定することで、そのスレッドはロックを解除し一時停止します。他のスレッドがnotify_all()を実行すると、一時停止中の全てのスレッドが実行可能状態になります。これによって、スレッドの同期を実現します。

実際にどんな挙動か確かめよう

上の説明は以下のサンプルと実行結果を先に確認した後の方がしっくりくるかもしれません。

ソースコード

#include <iostream>
#include <string>
#include <boost/thread.hpp>
#include <boost/bind.hpp>
using namespace std;
using namespace boost;

class HandleData {
 public:
  HandleData()
    : index_(0), iarr_len_(sizeof(iarr_)/sizeof(iarr_[0])), num_data_(0){}

  // データの追加
  void putData(int n) {
    // mutexインスタンスにロックをかける
    mutex::scoped_lock look(thread_sync_);
    while (index_ >= iarr_len_) {
      printf("[putData] waitn");
      // 引数のmutexインスタンスのロックを解除する。
      // notify_all()などが呼ばれるまでこのスレッドを一時停止する
      thread_state_.wait(thread_sync_);
    }
    printf("put: %d in iarr_[%d]n", n, index_);
    iarr_[index_++] = n;
    int loop = 1000000;
    while(loop--) ; // 空回し用
    thread_state_.notify_all();
  } // lockのデストラクタが呼ばれてロック解除(lookインスタンスのスコープ切れ)

  // データの取得
  int getData() {
    // putData()と同じくiarr_にスレッドセーフでアクセスする為にロックをかける
    mutex::scoped_lock look(thread_sync_);
    while (index_ <= 0) { // putData側のthread_state_.notify_all();が実行されるまで待つ
      printf("[getData] waitn");
      thread_state_.wait(thread_sync_);
    }
    num_data_ = iarr_[--index_];
    printf("get: %d in iarr_[%d]n", num_data_, index_);
    thread_state_.notify_all();
    return num_data_;
  } // lookのデストラクタでロック解除

 private:
  mutex thread_sync_;
  condition thread_state_;
  volatile int index_;
  int iarr_[100]; // putData()、getData()からアクセスされる変数
  const unsigned int iarr_len_;
  int num_data_;
};

void threadPut(HandleData *hd) {
  const unsigned int NUM_LOOP = 100;
  for (int i = 0; i < NUM_LOOP; i++) {
    hd->putData(i);
  }
}

void threadGet(HandleData *hd) {
  const unsigned int NUM_LOOP = 100;
  for (int i = 0; i < NUM_LOOP; i++) {
    hd->getData();
  }
}

int main()
{
  HandleData hd;
  thread thr_put(bind(&threadPut, &hd));
  thread thr_get(bind(&threadGet, &hd));
  thr_put.join();
  thr_get.join();
  return 0;
}

実行結果の一例

実行する環境によって、出力結果は変化します(格納・出力順序など)。

put: 0 in iarr_[0]
get: 0 in iarr_[0]
put: 1 in iarr_[0]
get: 1 in iarr_[0]
＜中略＞
get: 12 in iarr_[1]
get: 11 in iarr_[0]
[getData] wait
put: 13 in iarr_[0]
put: 14 in iarr_[1]
get: 14 in iarr_[1]
get: 13 in iarr_[0]
[getData] wait
put: 15 in iarr_[0]
put: 16 in iarr_[1]
＜中略＞
get: 95 in iarr_[0]
[getData] wait
put: 97 in iarr_[0]
put: 98 in iarr_[1]
get: 98 in iarr_[1]
get: 97 in iarr_[0]
[getData] wait
put: 99 in iarr_[0]
get: 99 in iarr_[0]

volatile 修飾子の必要性

52行目のメンバ変数のindexの宣言

volatile int index_;

volatile(揮発性)接頭語がつくと、コンパイラによる最適化を防ぐことができます。これによって、プログラムはindex_を読み取る際は必ずメモリから読みにいきます。これは変数が複数スレッドから常に書き換えられても、必ずそれが反映されるということです。

このサンプルでは付けなくても最適化によるバグの発生はなさそうかな…?

リファレンス

• Boost C++ Libraries – Chapter 17. Thread
  • Boost C++ Libraries – Synchronization

関連すると思われる記事：

• C++, pthread: スレッドの同期と排他制御 – MutexとCondition Variable
• C++, boost::thread : スレッドグループの生成と実行
• C++, boost::thread : スレッドの生成と実行
• java.io.StreamCorruptedExceptionが発生した原因とその解決策の一例
• Note of the Day – 2009-03-22

C++, boost::thread : スレッドの同期と排他制御 – mutex、conditionクラス is a post from: Yukun's Blog

それでは下記のサンプルで実際にその過程と実行結果を確認してみましょう。

ソースコード

#include <iostream>
#include <boost/bind.hpp>
#include <boost/thread.hpp>
using namespace std;
using namespace boost;

// マルチスレッドで実行する関数
void run(const char thr_name) {
  int count = 0;
  while(1) {
    if (++count % 100000000 == 0) // 空回り用の if 文
      cout << "Thread-" << thr_name << ": No." << count << endl;
  }
}

int main()
{
  const char chs[] = {'A', 'B', 'C', 'D'}; // 生成スレッドの名前の配列
  const int NUM_THREAD = sizeof(chs) / sizeof(chs[0]); // 配列の要素数の算出

  // スレッドグループの生成と実行開始
  thread_group thr_grp;
  for (int i = 0; i < NUM_THREAD; ++i) {
    thr_grp.create_thread(bind(&run, chs[i])); // create_thread()でrun()を別スレッドで実行
  }
  // join_all()で全スレッドの終了を待つ
  thr_grp.join_all();
  return 0;
}

実行結果の一例

実行する環境によって、出力結果は変化します(順序など)。

Thread-B: No.100000000
Thread-A: No.100000000
Thread-C: No.100000000
Thread-D: No.100000000
Thread-B: No.200000000
Thread-A: No.200000000
Thread-C: No.200000000
Thread-D: No.200000000
Thread-B: No.300000000
Thread-A: No.300000000
Thread-C: No.300000000
Thread-D: No.300000000
Thread-B: No.400000000
Thread-A: No.400000000
＜略＞

リファレンス

• Boost C++ Libraries – Chapter 17. Thread
  • Boost C++ Libraries – Thread Management

関連すると思われる記事：

• C++, boost::thread : スレッドの生成と実行
• C++, boost::thread : スレッドの同期と排他制御 – mutex、conditionクラス
• C++, pthread: スレッドの同期と排他制御 – MutexとCondition Variable
• java.io.StreamCorruptedExceptionが発生した原因とその解決策の一例
• Note of the Day – 2009-03-22

C++, boost::thread : スレッドグループの生成と実行 is a post from: Yukun's Blog

boost ライブラリの boost::thread は、上のような処理をラップして共通のインターフェイスとして実装されています。

boost/thread.hppの一部

#if defined(BOOST_THREAD_PLATFORM_WIN32)
#include <boost/thread/win32/thread.hpp>
#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
#include <boost/thread/pthread/thread.hpp>
#else
#error "Boost threads unavailable on this platform"
#endif

これによって、 boost がインストールされている OS ならば、同じコードでコンパイルすることが出来ます。さて、それでは boost::thread を使って基本的なスレッドの生成と実行を、以下の三つのパターンで確認してみます。

• 引数なし関数をマルチスレッドで実行
• 引数付き関数をマルチスレッドで実行
• メンバ関数をマルチスレッドで実行

引数なし関数をマルチスレッドで実行

ソースコード

#include <iostream>
#include <boost/thread.hpp>
using namespace std;
using namespace boost;

// 引数なし関数をマルチスレッドで実行

const int kCount =  100000000;
const int kInterval = 1000000;

void PrintHello() {
  for(int i = 0; i != kCount; ++i)
    if (!(i % kInterval)) cout << "Hello ";
}

void PrintWorld() {
  for(int i = 0; i != kCount; ++i)
    if (!(i % kInterval)) cout << "World! ";
}

int main() {
  thread thr_hello(&PrintHello); // PrintHello関数を実行するスレッドの生成、実行
  thread thr_world(&PrintWorld);

  thr_hello.join(); // thr_helloが走らせているスレッドの終了を待つ
  thr_world.join();
  return 0;
}

実行結果の一部抜粋


Hello World! Hello Hello World! Hello World! Hello World! Hello World! World! Hello World! Hello World! Hello World! Hello World! Hello World! World!


13行目: PrintHello() の for ループで kInteral を用いて空回りの負荷をある程度与えることで、スレッドの切り替え(スレッドスケジューリング)を出力に反映させやすくしています。仮に、単なるforループだと、マシン性能が高い場合スレッドの切り替え前に関数の実行が終了してしまう場合もありマルチスレッドか否かの確認がとり難いです。

23行目: thread クラスのインスタンスを生成しそのコンストラクタに、0引数の関数のアドレスを渡すことで、その関数を走らせるスレッドを生成、実行しています。

ここで、関数アドレスを表す表記は&関数名ですが、このアンパサンド「&」は省略できます。実際に確認しますと、

cout <<  PrintHello << endl;
cout << &PrintHello << endl;

の出力結果は、

003B17A8
003B17A8

となります。実行する環境によって上の数値は変わりますが、ここで大事なのは二つの出力が同値である、すなわち「関数名＝＝&関数名＝＝関数のアドレス」ということです。

余談ですが、関数アドレスを格納する関数ポインタを引数として渡すことも勿論可能です。例えば、

void (*fp)(void) = PrintHello; // 関数のアドレスを指す関数ポインタを宣言
thread thr_fp(fp); // ポインタが指すアドレスにある関数を走らせるスレッドを生成、実行

とも書けます。さて、次に引数をとる関数のスレッドの生成、実行方法を確認しましょう。

引数付き関数をマルチスレッドで実行

ソースコード

#include <iostream>
#include <boost/thread.hpp>
#include <boost/bind.hpp>
using namespace std;
using namespace boost;

// 引数付き関数をマルチスレッドで実行

const int kCount =  100000000;
const int kInterval = 1000000;

void PrintString(const char *str) {
  for(int i = 0; i != kCount; ++i)
    if (!(i % kInterval)) cout << str;
}

int main() {
  const char *kHello = "Hello ";
  const char *kWorld = "World! ";

  thread thr_hello(bind(&PrintString, kHello));
  thread thr_world(bind(&PrintString, kWorld));

  thr_hello.join();
  thr_world.join();
  return 0;
}

実行結果の一部抜粋


Hello World! Hello Hello World! Hello World! Hello World! Hello World! World! Hello World! Hello World! Hello World! Hello World! Hello World! World!


21行目: thread クラスのコンストラクタには関数オブジェクトも渡せるので、 boost::bind を用いて、その第二引数にPrintString 関数に渡したい引数を指定して、関数オブジェクトを生成しています。

さて、2つのスレッドの生成法を確認しましたが、 Java や他のオブジェクト指向をサポートしている言語を使い慣れている人には、違和感のある書き方だったかもしれません。私は「引数よりメンバ変数の呼び出しの方がいい」「C++ならオブジェクト指向だよね」と脊髄反射的に思ったり。
ということで最後は、

メンバ関数をマルチスレッドで実行

ソースコード

#include <iostream>
#include <boost/thread.hpp>
#include <boost/bind.hpp>
using namespace std;
using namespace boost;

// メンバ関数をマルチスレッドで実行

class PrintMessage {
 public:
  PrintMessage(const char* msg)
    :kMessage_(msg), kCount_(100000000), kInterval_(1000000) {}
  void run();

 private:
  const int kCount_;
  const int kInterval_;
  const char *kMessage_;
};

void PrintMessage::run() {
  for(int i = 0; i != kCount_; ++i)
    if (!(i % kInterval_)) cout << kMessage_;
}

int main() {
  PrintMessage hello("Hello ");
  PrintMessage world("World! ");

  thread thr_hello(bind(&PrintMessage::run, &hello));
  thread thr_world(bind(&PrintMessage::run, &world));

  thr_hello.join();
  thr_world.join();
  return 0;
}

実行結果の一部抜粋


Hello World! Hello Hello World! Hello World! Hello World! Hello World! World! Hello World! Hello World! Hello World! Hello World! Hello World! World!


おー、盛り上がってきましたね。

リファレンス

Boost C++ Libraries - Boost.Threads - <boost/thread.hpp>

関連すると思われる記事：

• C++, boost::thread : スレッドグループの生成と実行
• C++, boost::thread : スレッドの同期と排他制御 – mutex、conditionクラス
• C++, pthread: スレッドの同期と排他制御 – MutexとCondition Variable
• java.io.StreamCorruptedExceptionが発生した原因とその解決策の一例
• Note of the Day – 2009-03-22

C++, boost::thread : スレッドの生成と実行 is a post from: Yukun's Blog

実行結果

• 分割数: 15(ちょっとカクカクしてる)

• 分割数: 100

コード

// OpenGLで円の描画
#include <stdio.h>
#include <stdlib.h>
#include <gl/glut.h>
#include <gl/gl.h>
#include <math.h>

#define M_PI 3.14159265358979 // 円周率
#define PART 100 // 分割数

void display(void)
{
  int i, n = PART;
  float x, y, r = 0.5;
  double rate;

  glClear(GL_COLOR_BUFFER_BIT); // ウィンドウの背景をglClearColor()で指定された色で塗りつぶす
  glColor3f(1.0, 1.0, 1.0); // 描画物体に白色を設定
  glBegin(GL_POLYGON); // ポリゴンの描画
  // 円を描画
  for (i = 0; i < n; i++) {
    // 座標を計算
    rate = (double)i / n;
    x = r * cos(2.0 * M_PI * rate);
    y = r * sin(2.0 * M_PI * rate);
    glVertex3f(x, y, 0.0); // 頂点座標を指定
  }
  glEnd(); // ポリゴンの描画終了
  glFlush(); // OpenGLのコマンドを強制的に実行(描画終了)
}

void init(char *name)
{
  int width = 400, height = 400; // ウィンドウサイズ
  int w_window = glutGet(GLUT_SCREEN_WIDTH), h_window = glutGet(GLUT_SCREEN_HEIGHT); // デスクトップのサイズ
  int w_mid = (w_window-width)/2, h_mid = (h_window-height)/2; // デスクトップの中央座標

  glutInitWindowPosition(w_mid, h_mid);
  glutInitWindowSize(width, height);
  glutInitDisplayMode(GLUT_RGBA); // 色の指定にRGBAモードを使用
  glutCreateWindow(name);
  glClearColor(0.0, 0.0, 0.0, 1.0); // ウィンドウの背景色の指定
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0); // 座標系を設定(平行投影)
}

int main(int argc, char **argv)
{
  glutInit(&argc, argv); // glutの初期化
  init(argv[0]);
  glutDisplayFunc(display); // ディスプレイコールバック関数の指定
  glutMainLoop(); // イベント待ちループ
  return 0;
}

そういえば、リアルタイム処理などではポリゴンの数を抑えることで処理速度を稼いでましたね。

参考サイト: GLUTによる「手抜き」OpenGL入門

関連すると思われる記事：

• X Window System 上での描画色の変更
• 10進数を2進数に変換表示するC言語プログラム
• Java, Swing: JComponentのGraphicsオブジェクトを用いて直線を描画
• AS3でお絵かきFlashを作る (2)ボタン作成 – Flexコンポーネントの導入
• AS3でお絵かきFlashを作る (3)図形描画と配置選択ツールの追加

OpenGL: ポリゴンで円の描画 is a post from: Yukun's Blog

実装のポイント

• 閉じ括弧の有無の判定は、ファイルの終端が読み終わった後。
• 開き括弧の判定は、閉じ括弧を読み込んだ際に行い、スタックの最上位に対応する開き括弧があるか否かで。
• 入れ子の(または再帰的な)構造で、どの深さにスレッドがいるか調べるにはスタックを用いる。

ソースコード(C言語) valid_pare.c

#include <stdio.h>
#include <stdlib.h>

const int MAXSIZE = 128; // スタックサイズ(静的)
// スタックするデータ構造(Cell)
typedef struct brackets Brackets;
struct brackets {
  int kind; // 括弧の種類
  int line; // 位置：行
  int pos; // 位置：列
};
Brackets stack[128];
int pnt;

Brackets pop(void)
{
  if (pnt < = 0) {
    printf("error:stack empty.\n");
    exit(1);
  }
  pnt--;
  return stack[pnt];
}
void push(Brackets b)
{
  if (pnt >= MAXSIZE) {
    printf("error:stack fullness.\n");
    exit(1);
  }
  stack[pnt] = b;
  pnt++;
}
// stackが空(1)か否(0)か
int empty(void)
{
  return (pnt == 0) ? 1 : 0;
}
// スタックの最上位の文字種を返す
int peek()
{
  return stack[pnt-1].kind;
}
// 括弧の判別
int kind(int ch)
{
  int code;
  switch (ch) {
  case '(':
    code = 1;
    break;
  case ')':
    code = 2;
    break;
  case '{':
    code = 3;
    break;
  case '}':
    code = 4;
    break;
  case '[':
    code = 5;
    break;
  case ']':
    code = 6;
    break;
  default:
    code = 0; // 括弧以外の文字
    break;
  }
  return code;
}

int main()
{
  int ch;
  FILE *fp;
  char fname[64]; // ファイル名
  int k; // 文字の種類
  int line = 1, pos = 0;
  Brackets kakko, temp;

  pnt = 0; // スタックポインタ(GV)の初期化
  printf("Filename:");
  scanf("%62s", fname);
  if ((fp = fopen(fname, "r")) == NULL) {
    printf("\aCan't be opened.\n");
    exit(1);
  }
  //printf("%d行目\n", line);
  // ファイルから一文字ずつ読む
  while ((ch = fgetc(fp)) != EOF) {
    //putchar(ch);
    if (ch == '\n') {
      line++; pos=0;
      //printf("%d行目\n", line);
      continue;
    }
    pos++;
    //printf("%d", pos);
    k = kind(ch);
    if (k > 0) { // 文字が括弧の場合
      if (k % 2) { // 開き括弧の場合
        kakko.kind = k;
        kakko.line = line;
        kakko.pos  = pos;
        push(kakko);
      } else if (!empty() && (k == peek()+1)) {
        temp = pop(); // 対応する閉じ括弧があった
      } else {
        printf("対応する開き括弧がない");
        printf("(%d行目の%d文字目)。\n", line, pos);
      }
    }
  }
  puts("テキスト終端");
  fclose(fp);
  if (!empty()) {
    printf("対応する閉じ括弧がない。\n");
    while (!empty()) {
      temp = pop();
      printf("%d行目の%d文字目。\n", temp.line, temp.pos);
    }
  }
  return 0;
}

使用したText

(1+2)
ac)c
((3+6)ge))
(([y)
ij])(k
{5/3}

実行結果

D:\parentheses>gcc valid_pare.c
D:\parentheses>a.exe
Filename:pare.txt
対応する開き括弧がない(2行目の3文字目)。
対応する開き括弧がない(3行目の10文字目)。
対応する開き括弧がない(4行目の5文字目)。
テキスト終端
対応する閉じ括弧がない。
5行目の5文字目。
4行目の1文字目。
D:\parentheses>

改良するなら

• 関数を他のファイルに分けて、main側でインクルードする。
• スタック領域を動的に割り当てる。(Brackets *)emalloc(sizeof(Brackets))かな。
• スタック配列を伸縮性のある構造・操作関数で実装する。
• 結果の表示をコンパイラのエラー出力っぽくする。該当箇所に「^」をマーク。
• 他の言語で実装してみる(OOPを用いて等等)。
• 字句・構文解析のオープンソースを参考にする。

こういった小さなものを作りつつ、OOPのパターンに基づいて拡張性を考慮する今日この頃。

関連すると思われる記事：

• 10進数を2進数に変換表示するC言語プログラム
• Rubyで文字列から日本語文字をインデックス指定する
• Note of the Day – 2009-03-22
• Python: リストの要素の追加と削除、取出し – append()、extend()、pop()、remove()メソッド
• X Window System 上での描画色の変更

3種類の括弧の対応をチェックするC言語プログラム is a post from: Yukun's Blog

// filename: dtob.c
// convert decimal to binary
#include <stdio.h>

const int BitSize = sizeof(int) * 8; // 整数型のビットサイズを算出
void dtob(int x) {
  int bit = 1, i;
  char c[BitSize];

  for (i = 0; i < BitSize; i++) {
    if (x & bit)
      c[i] = '1';
    else
      c[i] = '0';
    bit <<= 1;
  }
  // 計算結果の表示
  printf("2進数: ");
  for ( i = BitSize - 1; i >= 0; i-- ) {
      putchar(c[i]);
  }
  printf("\n");
}

int main()
{
  int x = 0;
  do {
  printf("10進数を2進数に変換します(0で終了)\n");
  printf("xの値: ");
  scanf("%d", &x);
  dtob(x);
  } while (x != 0);
  return 0;
}

実行結果

[yu@localhost cpp]# gcc dtob.c
[yu@localhost cpp]# ./a.out
10進数を2進数に変換します(0で終了)
xの値: 5
2進数: 00000000000000000000000000000101
10進数を2進数に変換します(0で終了)
xの値: 8
2進数: 00000000000000000000000000001000
10進数を2進数に変換します(0で終了)
xの値: 100
2進数: 00000000000000000000000001100100
10進数を2進数に変換します(0で終了)
xの値: 256
2進数: 00000000000000000000000100000000
10進数を2進数に変換します(0で終了)
xの値: 1984949894
2進数: 01110110010011111110111010000110
10進数を2進数に変換します(0で終了)
xの値: 0
2進数: 00000000000000000000000000000000
[yu@localhost cpp]# 

ビットが0か1の判断するループ順序を逆にして、配列末尾に’\0′を代入すれば、計算結果の表示は配列の文字列表示ですみます。そうすると「計算結果の表示」の際にforループを使う必要はないなぁ、と書き終わった今思いました(ぇー)。

作成の経緯

以前、拡張ハッシュ法の削除関数を実装している際に、キーをバケットに振り分ける際のアドレス算出の処理部分にデバッグプリントが欲しくて作ったものです。

関連すると思われる記事：

• Python: 10進数整数を2進数文字列に変換する関数
• 3種類の括弧の対応をチェックするC言語プログラム
• OpenGL: ポリゴンで円の描画
• X Window System 上での描画色の変更
• Android: 10進数→2進数変換アプリ

10進数を2進数に変換表示するC言語プログラム is a post from: Yukun's Blog

#include <x11/Xlib.h>
#include <x11/Xutil.h>

unsigned long MyColor(display, color)
     Display *display;
     char *color;
{
  Colormap cmap;
  XColor c0, c1;
  cmap = DefaultColormap(display, 0);
  XAllocNamedColor(display, cmap, color, &c1, &c0);
  return (c1.pixel);
}

引数colorに以下に示す書式に則ったRGB色を表す文字列を代入しピクセル値を得ます。

"rgb:00/00/FF" (指定した色が青の場合)

ここで得られるピクセル値をXSetForeground関数に代入することでRGB値の指定による描画色の変更を行うことが出来ます。

RGB値指定が可能になることで表現できる色は飛躍的に増えますが、ソースプログラム中にいちいち値を指定した文字列を予め作成しておくのでは、少々非効率な面もあります。
特にフラクタルのような再起関数を用いる場合、繰り返し回数は等比級数的に増す場合もあり、カラフルな図形の表現を行うには別の手法を試みる必要があります。
そこで、上記のRGB値を指定する書式を自動生成する関数のプログラムを以下に示します。

#include <stdio.h>
#include <string.h> // for strdup()

// グローバル変数
char *comap[0x1000000]; // RGB形式のカラーマップ
int coindex = 0; // カラーマップ用パラメータ
int colimit = 0; // カラーマップの個数

// RGBカラーマップを生成
// iの可算度合は色のバラツキ度
void cremap()
{
  char str[16];
  int i, j;
  for(i=0, j=0; i< =0xFFFFFF; i+=0x2888, j++) {
    sprintf(str, "rgb:%02X/%02X/%02X",
      // i / 0xFFFF & 0xFF, i / 0xFF & 0xFF, i & 0xFF); // チョイ非効率
      (i >> 16) & 0xFF, (i >> 8) & 0xFF, i & 0xFF); // bit演算
    comap[j] = strdup(str);
    //puts(comap[i]);
    //printf("%d\n", i);
  }
  printf("%d\n", j);
  colimit = j; // 生成した色の数
  //exit(0);
}

sprintf関数を用いて書式を指定した文字列を生成することが出来ます。for ループのiの増分をi++に変更すれば0xFFFFFF色分のカラーマップを生成できます。ただし、このカラーマップの順序は少々とっぴで、パラメータj順に色を表示すると所所でカラージャンプがあるため、滑らかなグラデーションを生成したい場合はsprintfの引数の指定方法を変える必要があります。

最終的にはソースコード中で以下のように色を変更する一文を加えます。

XSetForeground(d,gc, MyColor(d, comap[lim(++coindex)]));

これによって生成されたフラクタル画像を下図に示します。左がイニシエータ、右がジェネレータ、中央が生成したフラクタル図形です。

関連すると思われる記事：

• OpenGL: ポリゴンで円の描画
• ActionScript: 画像ファイルをダウンロードして表示 – Loaderクラス
• Eclipse+CDTを用いてプロジェクトを作成する際の注意点
• 3種類の括弧の対応をチェックするC言語プログラム
• Java, Swing: JComponentのGraphicsオブジェクトを用いて直線を描画

X Window System 上での描画色の変更 is a post from: Yukun's Blog

#include <ctime> // for time()
#include <cstdlib> // for srand(), rand()
#include <iostream>
using namespace std;

#define MIN 10
#define MAX 21

int main()
{
  srand(time(NULL)); // 現在時刻を乱数の種の設定
  int lucky = MIN + rand() % (MAX - MIN); // MIN以上MAX未満の乱数を生成
  cout < < "生成した乱数は" << lucky << "です。n";
  for (int i = 0; i< 100; i++) { // 100個生成
    cout << MIN + rand() % (MAX - MIN) << " ";
  }
  return 0;
}

実行結果


C:cpp> g++ rand01.cpp
C:cpp> a.exe
生成した乱数は19です。
14 13 11 10 18 15 11 14 19 11 11 14 19 17 20 10 10 16 20 18 13 18 17 10 16 19 13 18 14 10 19 17 12 18 20 13 15 14 20 13 10 14 20 15 19 13 11 19 19 13 20 19 15 19 15 13 18 12 18 10 13 14 12 10 16 13 14 20 13 16 11 11 10 12 16 17 13 10 20 11 10 18 12 19 14 18 10 12 12 14 10 15 12 17 19 18 19 17 12 19
C:cpp>


関連すると思われる記事：

• Python: 乱数の生成 – random()、randint()、uniform()、seed()メソッド
• Python: モジュールにテスト関数を定義 – 重複のない乱数(整数MIN以上MAX以下)の生成
• Excel VBA: 指定した行、列内のテーブルのセルに乱数を格納
• Rで統計: ヒストグラムの描画 – hist()関数
• 10進数を2進数に変換表示するC言語プログラム

C++でMIN以上MAX未満の乱数を生成 is a post from: Yukun's Blog