WindowsXP以前であればzip圧縮を行ったファイルにパスワードをかけることができた。
しかし、WindowsVista以降からこの機能はなくなってしまった。

但し、圧縮時のパスワード設定機能がなくなっただけで、
解凍時のパスワード入力機能は残っているみたい。

よって、圧縮ツールを使ってパスワード付き圧縮ファイルを作れば
他の環境でも(たいていは)解凍できるはず。

圧縮ツールは「LhaPlus」とかがおすすめ。

「nanosleep()」で「0.1秒」スリープをする例。
┌──────────────────────────────────────┐
│struct timespec  req;                                                       │
│req.tv_sec  = 0;                                                            │
│req.tv_nsec = 100 * 1000 * 1000;                                            │
│nanosleep(&req, NULL);                                                      │
└──────────────────────────────────────┘

「timespec」構造体は以下のような内訳で、
ナノ秒は「0～999,999,999」の範囲で指定可能。
┌──────────────────────────────────────┐
│struct timespec {                                                           │
│    time_t   tv_sec;   // 秒                                                │
│    long     tv_nsec;  // ナノ秒                                            │
│};                                                                          │
└──────────────────────────────────────┘

ちなみに、シグナルで一時停止され、再度復帰した場合には
第二引数にスリープしていない残り時間が戻ってくるので
再度実行すれば、全部で想定通りの合計になるらしい。
但し、様々な理由から合計値は若干ずれる模様。
┌──────────────────────────────────────┐
│struct timespec  req,rem;                                                   │
│if (nanosleep(&req, &rem) == -1) {                                          │
│    if (errno == EINTR) {                                                   │
│        nanosleep(&rem, NULL);                                              │
│    } else {                                                                │
│        nanosleep()のエラー;                                                │
│    }                                                                       │
│}                                                                           │
└──────────────────────────────────────┘
なお、より厳密にしたい場合には「clock_nanosleep()」という関数があるらしい。

また、ナノ秒までいらず秒単位でいいのであれば「sleep()」が使える。
┌──────────────────────────────────────┐
│残り秒 = sleep(指定秒);                                                     │
│if (残り秒 > 0) {                                                           │
│    sleep(残り秒);                                                          │
│}                                                                           │
└──────────────────────────────────────┘
みたいな感じになる。

open()で取得されるファイルディスクリプタは
同一ファイル名であっても、openした順番に別の連番となる。

flock()にとる排他は、ファイルディスクリプタ単位ではなく
ファイルディスクリプタが対象とするファイル単位で行われる。

むしろ同一ファイルディスクリプタであれば排他対象外となる。

┌──────────────────────────────────────┐
│open(ファイル名,…);                           →ファイルディスクリプタ「1」│
│open(ファイル名,…);                           →ファイルディスクリプタ「2」│
│flock(1, LOCK_EX | LOCK_NB);                                        →OK(0) │
│flock(2, LOCK_EX | LOCK_NB);                                        →NG(-1)│
│flock(1, LOCK_EX | LOCK_NB);                                        →OK(0) │
└──────────────────────────────────────┘

┌──────────────────────────────────────┐
│flock(fd,                                                                   │
│      LOCK_SH);                                                             │
└──────────────────────────────────────┘
基本的に「flock()」でロックをかけるが、先に他でロックをかけていた場合は
「flock()」の中でずーっと待ち状態となる。
これでは埒があかないので、「LOCK_NB」を付加して、
ロック中の場合はエラーとするようにする。
┌──────────────────────────────────────┐
│if (flock(fd, LOCK_SH | LOCK_NB) == -1) {                                   │
│    if (errno == EWOULDBLOCK) {                                             │
│        他でロック中;                                                       │
│    } else {                                                                │
│        flock()エラー;                                                      │
│    }                                                                       │
│}                                                                           │
└──────────────────────────────────────┘
ロック中で即エラーするのもなんだから、リトライ処理で囲って
若干のスリープ処理なんかを挟み込んで、気にならない程度にリトライを
試みさせてみるのもよい。
┌──────────────────────────────────────┐
│for (i = 0; i <= リトライ回数; i++ ) {                                      │
│    if (flock(fd, LOCK_SH | LOCK_NB) == -1) {                               │
│        if (errno == EWOULDBLOCK) {                                         │
│              スリープ処理;                                                 │
│              continue;                                                     │
│        } else {                                                            │
│            flock()エラー;                                                  │
│            break;                                                          │
│        }                                                                   │
│    }                                                                       │
│    ロック成功フラグ = true;                                                │
│    break;                                                                  │
│}                                                                           │
│if (!ロック成功フラグ) {                                                    │
│    close(fd);                                                              │
│    return;                                                                 │
│}                                                                           │
└──────────────────────────────────────┘

┌──────────────────────────────────────┐
│読込件数 = fread(読込先,                                                    │
│                 一件あたりのサイズ,                                        │
│                 要求件数,                                                  │
│                 fp);                                                       │
└──────────────────────────────────────┘
「fread()」は「一件あたりのサイズ(列)」×「要求件数(行)」のように指定して
面としてデータを取得する関数だ。

じゃ、こんな感じで端数が出た時はどうなるのか？
┌──────────────────────────────────────┐
│■■■■                                                                    │
│■■■■                                                                    │
│■■■                                                                      │
└──────────────────────────────────────┘

ちゃんと端数分も含めて最後まで取得してくれる。
┌──────────────────────────────────────┐
│■■■■                                                                    │
│■■■■  ←読込件数2件                                                     │
│■■■←ここまで取得される                                                  │
└──────────────────────────────────────┘
読込件数は完全に読み込まれた行数分となるので、要求件数と比較すると足りなくなる。

よって、「読込件数＜要求件数」でEOF到達が認識できる(厳密には「feof()」と併用)。

他のポイントとしては、端数以降の部分はひっぱってこないということ。
┌──────────────────────────────────────┐
│■■■■                                                                    │
│■■■■                                                                    │
│■■■□←この部分は読込先に上書されない                                    │
└──────────────────────────────────────┘
「列×行」分ひっぱってくれて、余白は0で埋めてくれたりはしないってこと。
ま、足りない行分もひっぱってこないから当然といえば当然。
とにかく事前の初期化は大事なようだ。

ま、以下のような関数をつくってみた。
┌──────────────────────────────────────┐
│function randHit(inHit, inAll) {                                            │
│    return (Math.floor(Math.random() * inAll) < inHit) ? true : false;      │
│}                                                                           │
└──────────────────────────────────────┘
以下のように使う。
┌──────────────────────────────────────┐
│if (randHit(30, 100)) {                                                     │
│    alert('あたり');                                                        │
│} else {                                                                    │
│    alert('はずれ');                                                        │
│}                                                                           │
└──────────────────────────────────────┘
30%の確率で「あたり」になる。

ま、いろいろ使える。

所定の文字数まで穴埋めするには「lpad()」・「rpad()」が使える。
┌──────────────────────────────────────┐
│SELECT lpad(1::text  , 2, '_');                                     →「_1」│
│SELECT lpad(12::text , 2, '_');                                     →「12」│
│SELECT lpad(123::text, 2, '_');                                     →「12」│
├──────────────────────────────────────┤
│SELECT rpad(1::text  , 2, '_');                                     →「1_」│
│SELECT rpad(12::text , 2, '_');                                     →「12」│
│SELECT rpad(123::text, 2, '_');                                     →「12」│
└──────────────────────────────────────┘
先頭の「l」は「left」(左)、「r」は「right」(右)を意味する。
所定の文字数をはみ出した分は切り捨てられてしまうようだ
(「rpad()」の場合も左から採用され、右が切り捨てられるから注意)

  ちなみに、「repeat()」の代用もできる。
┌──────────────────────────────────────┐
│SELECT repeat('*', 3);                                             →「***」│
│SELECT lpad('', 3, '*');                                           →「***」│
│SELECT rpad('', 3, '*');                                           →「***」│
└──────────────────────────────────────┘

以下のような感じか。(もっといい方法がありそうだが)
┌──────────────────────────────────────┐
│char  test[4];                                                              │
│memset(test, 0, sizeof(test));                                              │
│printf("test:  %02x %02x %02x %02x", test[0], test[1], test[2], test[3]);   │
└──────────────────────────────────────┘

以下は、実体が3文字のファイルを「fread()」で「2×2」で読み込んで
4文字目の領域はどうなるかを調査した場合の例。
┌──────────────────────────────────────┐
│char  test[4];                                                              │
│memset(test, 0, sizeof(test));                                              │
│FILE*  fp = fopen("test.txt", "r");                                         │
│printf("%d = fread()", fread(test, 2, 2, fp));                              │
│fclose(fp);                                                                 │
│printf("test:  %02x %02x %02x %02x", test[0], test[1], test[2], test[3]);   │
└──────────────────────────────────────┘

ファイルは「fopen()→fclose()」の流れで扱うものだが、
同一ファイルについて「fopen()→fopen()」してしまった場合はどうなるのか？

処理系によって違うらしいので一概にはいえないが、
ある処理系の場合は、異なるファイルポインタ(fp)のアドレスが取得できたので
「fopen()」毎に、FILE構造体が生成されるようだ。
但し、同時にオープンできるファイルの数に上限があるようなので
無尽蔵に「fopen()→fopen()→…」を繰り返すといつかはエラーになるみたい。

Excelなんかでも用いられる文字列を並べて棒グラフっぽく表示する例。
┌──────────────────────────────────────┐
│SELECT キー, repeat('*', 列) AS "graph" FROM 表;                            │
└──────────────────────────────────────┘