ゲームプログラマの落書き帳：C/C++ 豆知識

C++ の単純な問題。
```
#include <vector>
```
して、
```
std::vector<std::vector<int>> hoge;
```
と記述したら、コンパイルエラーが出ました。どんなエラーが出たでしょうか？

答え。GCC だと
```
error: '>>' should be '> >' within a nested template argument list
```
と出た。構文的に ">>" と ">" 2 個は別だからね。
しかし VC++（VC8）だと警告すら出ない。移植しようとするとエラー、なんてことになるわけだ。M$ の template 関連実装は適当すぎて困る。

ちなみに C++0x では、'>' が予測されるときは、後に何が続いていても '>' とみなす（">>", ">>=", ">=" が該当）。GCC ならオプション -std=c++0x もしくは -std=gnu++0x でサポート。
C++ の話。
```
template<typename F, typename F f>
int TmplFunc(int n) { return f(n); }
```
って、VC++ では通るけど GCC では通らないのね。
```
template<typename F, F f>
```
なら、VC++ でも GCC でも通るなぁ。VC++ の文法チェックが甘い気がするけど、C++ の掟がどうなのかは知らん（ぉぃ）。

C++ の話。class Hoge; だけ宣言した後、別の class 内 template で Hoge のメンバを使うと、それだけで前方参照エラーになるコンパイラと通るコンパイラがある。template の解析アルゴリズムが違うんだなぁ。困ったもんだ。

具体的な例。g++-3 では通るが g++-4 では通らない。
sample.cpp

#include <cstdio>

// エラー回避用 //
template<class T>
void AnyPrint(T *p)
{
    p->Print();
}

class Hoge;

class Foo
{
public:
    Hoge *GetPtr() { return m_pHoge; }
    void SetPtr(Hoge *p) { m_pHoge = p; }

    template<class T>
    void Func()
    {
        GetPtr()->Print();
//      AnyPrint<T>(GetPtr());    // こうすると通る //
    }

private:
    Hoge *m_pHoge;
};

class Hoge
{
public:
    void Print() { printf("hoge\n"); }
};

int main()
{
    Foo foo;
    Hoge hoge;

    foo.SetPtr(&hoge);
    foo.Func<Hoge>();
    return 0;
}

文字列関連

C 言語の問題。
```
sprintf(tmp_fname, fname);
```
さて、このコードにはどんな危険性があるでしょうか？（2種類あります）

答え。「バッファオーバーフロー（tmp_fname のサイズが足りない場合）」と、「fname に '%' が含まれている場合」の 2 つ。どっちもかなり危険。基本だけど、寝ボケてるとやらかしそう。
安全にするなら、
```
sprintf(tmp_fname, "%.255s", fname);
```
とか sprintf_s() とか std::string を使う（C++）とかいろいろあるけど、それぞれ一長一短なので、まぁ状況によって使い分けかな。

ちなみに、余裕を持とうとして char tmp_fname[0x10000]; などと巨大な配列をローカル変数にすると、スタックを大量消費するので危険。 static にすればスタックは使用しなくなるけど、再帰／再入不可になりがち。
ローカル変数は多くても 1KB 以内程度に抑えて、スタックを大事にしよう。
以前にスタック使用量を調べるのに使ったのは objdump と stackcheck.pl （ちょこっと改造）。ググって。
C 言語の演習問題。 char s[30001] に、 "abc" を 1 万個つなげた文字列を格納せよ。ただしなるべく見やすいコードで高速に。

悪い例その 1。 char s[30001] = "abcabcabcabcabc （以下略）は速いけど猛烈に見づらいので却下。言うまでもないかｗようするにループで処理せよ、と。

悪い例その 2。
```
int i;
s[0] = 0;
for(i = 0; i < 10000; i++) {
    strcat(s, "abc");
}
```
超遅い。毎回 strcat() が文字列の終端を探すので、長くなるほど遅くなる。

てなわけで、終端を覚えておきたい。ポインタで覚えておかずに、
```
size_t len = 0;
for(i = 0; i < 10000; i++) {
    strcpy(&s[len], "abc");
    len += strlen("abc");
}
```
などと長さで処理すると、バッファオーバーフロー対策も追加しやすい。
C++ なら、
```
std::string s;
for(i = 0; i < 10000; i++) {
    s += "abc";
}
```
で済むし、速度もわりと速い。ただし s = s + "abc"; と書いてしまうと激遅なので注意。

余談。主題は文字列を大量につなげることだったけど、文字列の繰り返しに関して言えば、Perl なら "abc" x 10000; 、PHP なら str_repeat("abc", 10000); で生成できる。便利。
C++ なら BOOST_PP_REPEAT マクロで 256 個までなら展開できるようだけど、1 万個は厳しい。できたとしても実行バイナリがでかくなる上に、プリプロセッサ出力が大変なことになるので、おすすめできない。
C 言語の問題。
```
int i;
for(i = 0; i < (int)strlen(s); i++) {
    if (s[i] == '*') break;
}
printf("%d\n", i);
```
バグは無いとして、このコードで良くないのはどの部分？

答え。ループで毎回 strlen(s) を呼び出しているので遅い……かもしれない。ループ内で s を書き換えてないので、最適化すればループの前に出されるかも。出されないかも。コンパイラ次第。
てなわけで、自分で len = strlen(s); などとループの前に出すか、strlen() を使わずにポインタで処理するなど。速い CPU で開発していると、こういう無駄な処理に気付きにくいね。ループ内の処理にはちょっと気を遣おう。

数値関連

C 言語の問題。
```
printf("%d\n", -0x80000000 / -0x40000000);
```
さていくつ？ VC++ では変な警告が出た。GCC では警告出ないな。

答えは 0。-0x80000000 は unsigned の 0x80000000 と見なされちゃうのだ。怖いね～。 -0x7fffffff までは signed のまま。
unsigned int と signed int の演算は unsigned int に揃えられるので、-0x40000000 は 0xc0000000 になる。結局 0x80000000 / 0xc0000000 となって、整数除算だから 0。

VC++ では、
```
符号付きの値を代入する変数は、符号付き型にキャストしなければなりません。
負の整数定数が符号なしの型に変換されました。
```
という警告が出る。後者はいいとして、前者の「変数」って、使ってねーよ。
試しに英語モードにしてみると、
```
unary minus operator applied to unsigned type, result still unsigned
```
と出てきた。翻訳者出てこい。間違って別の警告を翻訳したのかな？それにしたって意味わからん。
ちなみにちゃんと訳すと、
```
符号なしの値に負号が適用されましたが、結果は符号なしのままです。
```
てなところ。

GCC では -2147483648 なら、
```
this decimal constant is unsigned only in ISO C90
```
という警告が出る。16 進や 8 進だと出ない。ぬぅ。
あ、そうそう。
```
int a = -0x80000000;
printf("%d\n", a / -0x40000000);
```
なら、ちゃんと 2 になる。念のため。
C 言語の問題。
```
unsigned short a = -1, b = -1;
printf("%d\n", a * b);
```
さていくつ？ちなみに警告は出ないよ。あ、それと int が 16bit の環境とか完全無視（ぉぃ）。

答えは -131071。(int)0xffff * (int)0xffff だね。short や char などの演算は、まず int に変換される。
unsigned short a = -1; で警告が出ないのは、-0x8000～0xffff に収まっているから。と言っても VC++ と GCC での話で、C 言語の掟かどうかは知らない（ぉぃ）。
C 言語の問題。
```
printf("%d %d\n", -5 << 2, -255 >> 4);
```
はいくつといくつ？

答えは -20 と -16 ……と言いたいところだけど、実は負の数の場合、左シフトの挙動は未定義、右シフトは処理系依存なのだ。
負の数の表現方法は、普通の「2 の補数」以外に「1 の補数」「符号と絶対値」というのも認められているらしい。だから負の数のシフトは未定義だったり処理系依存だったりするのね。
ちなみに普通、「<< 2」は「* 4」と同じになるけど、「>> 4」は負の数に対しては「/ 16」とは少し違う。たとえば -255 >> 4 は -16、-255 / 16 は -15。マイナス無限大方向丸めと、0 方向丸めの違い。
あと a << b や a >> b において、b は 0～(a のビット数 - 1) の範囲じゃないとダメ。処理系によっては 10 >> -1 を 20 にしてくれたりするけど、移植性無し。
「double 型から整数部と小数部を別々に取り出したいときに、どう書けばスマートになるかなぁ‥‥」という質問。
```
xi = (x >= 0.0) ? floor(x) : ceil(x);
xf = x - xi;
```
とか。xf = fmod(x, 1.0); は重そう。
C 言語の問題。
```
printf("%d\n", 1+~-1["hoge"]);
```
さていくつ？たぶん難しいと思うけど、実用性はゼロｗ

答えは 111（'o' の ASCII コード）。
```
char str[]="hoge"; printf("%d\n", 1+~-str[1]);
```
と置き換えると、少しは見やすいかな？
まず、a[b] は a と b がポインタと整数の組み合わせなら *((a) + (b)) と同じ、というのを知らないとわかんないね。知ってても役に立たないけどねｗ
あとは 1+~x = -x だから、1+~-x = x 。これはプログラマなら理解してほしいところだけど、ちと難しいかも。
C 言語の問題。
```
double a; a = 0 / 0; printf("%g\n", a);
```
実行するとどうなる？

答え。VC++ ではコンパイルでエラーだけど、GCC では 0 除算で落ちる。「nan と表示される」は間違い。整数除算だからね。某所で気になったので念のため。

その他

C 言語のビットフィールド、並び順は決まっていない。他人の書いたプログラムが並び順に依存していて、他の環境に持って行ったら誤動作してひどい目にあった。
C 言語のエスケープシーケンス（「\n」「\t」など）に、なんで「\?」（「?」だけになる）があるのかと思ったら、トライグラフのせいか。
C 言語の問題。
```
int foo(int x[3]) {
    return (int)sizeof(x);
}
```
という関数がある場合、
```
int a[3];
printf("%d %d\n", sizeof(a), foo(a));
```
はいくつといくつ？

答えは 32bit 環境なら 12 と 4。まぁ細かいことは気にすんな（ぉぃ）。では後者を 12 にするにはどうすればいい？
答え。
```
return (int)sizeof(int) * 3;
```
あっはっは。まぁ C 言語で関数に配列を渡すと、（初めの）添え字は意味無いんだよね。これはもうしょうがないのよ。
で、他には、
```
typedef struct {
    int x[3];
} hoge_t;
```
てな感じで構造体に入れちゃうとか。でもなにかとめんどくさいね。
C++ なら、
```
int foo(int (&x)[3])
```
と参照渡しにすれば sizeof で取得できる。これならスッキリかな～。&x に括弧付けないとエラーになるから注意。
C 言語の問題。
```
unsigned int a[2] = {1, 2};
int *p = (int *)(&a + 1);
printf("%d\n", *(p - 1));
```
さていくつ？

答えは 2。「a」でなく「&a」だと配列全体へのポインタになり、&a + 1 は配列の直後のアドレスになる。
GCC 4.5 の C++0x 対応状況を見てみた。だいぶ実装されたけど、まだまだ残ってるねぇ。しかし C++ はどこまで肥大化するのやら。
http://gcc.gnu.org/gcc-4.5/cxx0x_status.html
C++ の話。
```
cin >> string;
cout << string << endl;
```
の「>> , <<」ってどういう仕組み？という質問があった。Google でうまく検索できなかった模様。記号は検索できないんだよね。残念。「演算子オーバーロード」でググろう。
SJIS で危ないのは、// コメントの最後に「表」「能」などの 2 バイト目が 0x5c（バックスラッシュに相当）の文字がある場合。SJIS 非対応だと次の行につながって、次の行もコメントとみなされてしまう。かなりヤバい。
「x++;」と「++x;」では、「++x;」のほうが速いことが多い。
「x++;」は「x を退避して、++ の処理をして、退避した x を返す」ので、退避する手間がかかるため。
基本型では結局差が出ないことが多いけど、C++ で演算子オーバーロードを利用した時に差が出やすい。特にイテレータは注意。