シンボリックリンクの見分け方。「ls -l」を実行する。
┌──────────────────────────────────────┐
│$ ls -l                                                                     │
│-rw-rw-r--    1 root     root            2 Jan  1  1970 A                   │
│lrwxrwxrwx    1 root     root            2 Jan  1  1970 B -> A              │
│-rw-rw-r--    1 root     root            2 Jan  1  1970 Z                   │
└──────────────────────────────────────┘
左から一番目のファイル属性の一番左がシンボリックリンクを表しており、
「l」(小文字のL)となっていればそれがシンボリックリンク。
また、リンク名の横に「-> ファイル名」がついているので一目瞭然。


ハードリンクの見分け方。「ls -l」を実行する。
┌──────────────────────────────────────┐
│$ ls -l                                                                     │
│-rw-rw-r--    3 root     root            2 Jan  1  1970 A                   │
│-rw-rw-r--    3 root     root            2 Jan  1  1970 B                   │
│-rw-rw-r--    3 root     root            2 Jan  1  1970 C                   │
│-rw-rw-r--    1 root     root            2 Jan  1  1970 Z                   │
└──────────────────────────────────────┘
左から二番目の項目がハードリンク数。
上記でいえば「A、B、C」が互いにハードリンクしているため「3」となっている。

コピーとハードリンクとシンボリックリンクの比較。
┌───────┬───────┬───────┬──────────────┐
│    コピー    │ ハードリンク │ シンボリック │                            │
├───────┼───────┼───────┼──────────────┤
│$ echo "a" > A│$ echo "a" > A│$ echo "a" > A│←「A」を生成               │
│$ cat A       │$ cat A       │$ cat A       │←「A」の中身を確認         │
│a             │a             │a             │                            │
├───────┼───────┼───────┼──────────────┤
│$ cp A B      │$ ln A B      │$ ln -s A B   │←「B」を生成する           │
│$ cat B       │$ cat B       │$ cat B       │←「B」の中身を確認         │
│a             │a             │a             │←「A」の中身と同じ         │
├───────┼───────┼───────┼──────────────┤
│$ echo "b" > B│$ echo "b" > B│$ echo "b" > B│←「B」の中身を変更         │
│$ cat B       │$ cat B       │$ cat B       │                            │
│b             │b             │b             │                            │
│$ cat A       │$ cat A       │$ cat A       │←「A」の中身を確認         │
│a             │b             │b             │                            │
└───────┴───────┴───────┴──────────────┘
コピーの場合は、独立した二つのデータが生成されるので、互いに影響を与えない。
ハードリンクの場合は、一つのデータを共有するので、互いに影響を与える。
シンボリックリンクの場合は、シンボルが実体のようにふるまう。
よって、シンボルを更新すると実体が更新される。

シンボリックリンクの実体がなくなると、シンボルを指定しても該当なしエラーとなる。
┌──────────────────────────────────────┐
│$ ls -l                                                                     │
│lrwxrwxrwx    1 root     root            2 Jan  1  1970 B -> A              │
│$ rm A                                                                      │
│$ cat B                                                                     │
│cat: B: No such file or directory                                           │
└──────────────────────────────────────┘

リンクを生成する。
┌──────────────────────────────────────┐
│$ ln -s ファイル名 リンク名                                                 │
└──────────────────────────────────────┘

リンクの内容を確認する。
┌──────────────────────────────────────┐
│$ ls -l                                                                     │
│lrwxrwxrwx    1 root     root          8 Jan  1  1970 リンク名 -> ファイル名│
└──────────────────────────────────────┘

リンクを削除する。
┌──────────────────────────────────────┐
│$ rm リンク名                                                               │
└──────────────────────────────────────┘

ちなみに「-s」をつけないとハードリンクをの生成となる。
┌──────────────────────────────────────┐
│$ ln ファイル名 リンク名                                                    │
└──────────────────────────────────────┘

以下の違いをまとめてみた。
・コピー            …実体が二つになる。
・ハードリンク      …実体は一つで窓口が二つになる。
                      一方の窓口から変更をすると、他方へも反映された形となる。
                      窓口がすべてなくなった時点で実体もなくなる。
・シンボリックリンク…ショートカット(実体がなくなってもリンク切れ状態で残る)。
                      ハードリンクに対してソフトリンクとも呼ばれる。

注意点としては
・ハードリンクはパーティーションをまたがると使えない。
・シンボリックリンクが使えない特殊なシステムもある。

「x ≧ y」が前提で、以下の再帰関数を使えば最大公約数が求まるらしい。
┌──────────────────────────────────────┐
│int gcd(int x, int y) {                                                     │
│    return (y == 0) ? x : gcd(y, x % y);                                    │
│}                                                                           │
└──────────────────────────────────────┘
大きい方から小さい方を削除する。
それを繰り返すだけで最大公約数が求まるってことらしい。
もちろん、最後にきれいにゼロになった時だけで、
そのゼロになる瞬間の直前の値が最大公約数ってこと。
ま、たいていは「1」になってしまうもんだけど、「2」以上の場合もある。
(っていうか「2」以上の場合の方が最大公約数の代表みたいな感じだけど)

以下に例をあげてみた。大きい方か小さい方を削っていくだけだ
┌──────────────────────────────────────┐
│24→ 6→ 6→ 6      ←最大公約数 6                                          │
│18→18→12→ 6→ 0                                                          │
├──────────────────────────────────────┤
│ 4→ 1              ←最大公約数 1                                          │
│ 3→ 3→ 2→ 1→ 0                                                          │
└──────────────────────────────────────┘

大きい方と小さい方が変わらず何回か繰り返す部分があるが
これを端折ってくれるのが剰余(プログラムでいうところの「%」)。
┌──────────────────────────────────────┐
│24→ 6              ←最大公約数 6                                          │
│18→18→ 0                                                                  │
├──────────────────────────────────────┤
│ 4→ 1              ←最大公約数 1                                          │
│ 3→ 3→ 0                                                                  │
└──────────────────────────────────────┘
こんな感じでショートカットしてくれる。

プログラムっていうよりこれ考えたユークリッドが偉い！って感じ。
因数分解とかして求めるより断然速いらしい。

設計の上をいく設計って感じだ。

数値型から文字型に変換するなら、書式付き変換できるsprint系がいいかも。
┌──────────────────────────────────────┐
│sprintf(文字列, "%d", 数値);                                                │
│snprintf(文字列, sizeof(文字列), "%d", 数値);                               │
└──────────────────────────────────────┘
ファイルとかに出力するなら、「fprintf()」とかもあるけど。

これの対応馬(っていうと類似っぽな、真逆な存在)は、sscanf系。
文字型(文字列)から数値に変換してくれる。
┌──────────────────────────────────────┐
│int  sscanf(文字列, "%d", 数値);                                            │
└──────────────────────────────────────┘

sprintf系もsscanf系も複数の変換も一気にできるところが魅力か。
┌──────────────────────────────────────┐
│sprintf(文字列, "%d,%d", 数値, 数値);                                       │
│snprintf(文字列, sizeof(文字列), "%d,%d", 数値, 数値);                      │
├──────────────────────────────────────┤
│int  sscanf(文字列, "%d,%d", 数値, 数値);                                   │
└──────────────────────────────────────┘

文字型を数値型に変換するには以下の関数を使う。
┌──────────────────────────────────────┐
│int                 atoi(const char* 文字);                                 │
│long                atol(const char* 文字);                                 │
│long long int       atoll(const char* 文字);                                │
│double              atof(const char* 文字);                                 │
├──────────────────────────────────────┤
│long                strtol(const char* 文字列, char** 不正文字, int 基数);  │
│float               strtof(const char* 文字列, char** 不正文字);            │
│double              strtod(const char* 文字列, char** 不正文字);            │
│unsigned long       strtoul(const char* 文字列, char** 不正文字, int 基数); │
│long long           strtoll(const char* 文字列, char** 不正文字, int 基数); │
│unsigned long long  strtoull(const char* 文字列, char** 不正文字, int 基数);│
│long double         strtold(const char* 文字列, char** 不正文字);           │
└──────────────────────────────────────┘
a系は一文字が対象で、str系は文字列の一文字が対象。

逆に、数値型を文字型(文字列)に変換するには以下の関数を使う。
┌──────────────────────────────────────┐
│char*  itoa(int 数値, char* 文字列, int 基数);                              │
│char*  ltoa(long 数値, char* 文字列, int 基数);                             │
└──────────────────────────────────────┘
こちらはstr系(「ltostr」とか)はないみたい。
ま、a系で文字列を返してる(str系を兼ねている)しね。

数値型に関連するデータは以下の通り。
┌─────────┬──────────┬────┬─────────┬──┐
│signed char       │unsigned char       │ 1バイト│charは文字型専用  │ 2桁│
├─────────┼──────────┼────┼─────────┼──┤
│       short      │unsigned short      │ 2バイト│正式にはshort int │ 4桁│
├─────────┼──────────┼────┼─────────┼──┤
│       int        │unsigned int        │ 4バイト│ 2バイトの場合あり│ 9桁│
├─────────┼──────────┼────┼─────────┼──┤
│       long       │unsigned long       │ 4バイト│正式にはlong int  │ 9桁│
├─────────┼──────────┼────┼─────────┼──┤
│       long long  │unsigned long long  │ 8バイト│後から追加        │18桁│
├─────────┼──────────┼────┼─────────┼──┤
│       float      │unsigned float      │ 4バイト│                  │38桁│
├─────────┼──────────┼────┼─────────┼──┤
│       double     │unsigned double     │ 8バイト│                   308桁│
├─────────┼──────────┼────┼─────────┼──┤
│       long double│unsigned long double│ 8バイト│10バイトの場合あり 308桁│
└─────────┴──────────┴────┴─────────┴──┘
        ※(char型以外)「signed」は付けても付けなくても同じ
        ※桁数はフルに収まる桁数(もし「～127」ならば「～99」まで収まるから2桁)

「isdigit()」は「'0'～'9'」なら真(0以外)を返却し、
それ以外なら偽(0)を返却する便利な関数だ。

なのでその定義が「bool isdigit(char c);」とかと思ったら、
「int isdigit(int c);」なのだ。

ま、関数の型のintは、0からそれ以外で解釈するからいいとして
なんで引数はint型なの？

型に従って変換とかすると(「isdigit(atoi('1'))」みたいに)、偽になってしまう。

これは、数値の「0～9」は「0x00～0x09」で、
文字の「'0'～'9'」は「0x30～0x39」の違いがあって、
「0x30～0x39」なら真って判定しようと待ち構えていたら
「0x00～0x09」が入力されたのでアウト(偽)！って判定したってことらしい。

この場合は直接(「isdigit('1')」みたいに)でいいらしい。

なんだかややこしいC言語の世界。

int型は最速なんです、便利なんです、万能なんですってことなんだろうか。
ま、変換だなんだで時間をくうよりは少々わかりにくくてもダイレクトにってのが
C言語だからね(だからとっつきづらいし、罠が多い(覚えてらんないよ))。

つーから、マジマジと定義を見るまでint型に気づかなかった(反省)。

エラーが発生した場合に対処するパターンとしては以下がある。

・気にしない                      →気にしなくていいのなら
・既定値だと解釈する              →そういうことも織り込み済みなら
・違う処理を試す                  →試す価値があるのなら
・入力や処理をやり直す(限度あり)  →何回かやればうまくいきそうなら
・再起動する                      →チャラにしたらうまくいくかもしれないなら
・上位に通知(継承)する            →自己解決できないのなら
・打ち切る                        →お手上げ

どれもエラーログとかに発生自体を記録しておくことになるであろう。

画像の周囲を囲いたい場合の方法。

メニューから、「イメージ→キャンバスサイズ」を選択し
「アンカー」を「上下中央」(つまりど真ん中)に設定し、
「幅」および「高さ」を微妙に広げる(対称的に広がるので偶数分広げる)。

広がった部分が白地キャンバスとなるので、「魔法の杖」の「許容範囲0%」で
その部分を選択する。(うまく選択できるかな？)

そんで、そこに「ペイント缶」で色(黒とか)を投入。

ってな感じです。