HN 日本語サマリー

← 一覧へ戻る
プログラミング

trueの補数はfalseの時を除いてtrueである

The complement of true is true, except when it's false (dryperspective.github.io)

65 pointsby aw162110725 コメント

要約

C++における整数昇格(integral promotion)とブーリアン変換の挙動について解説しています。特に、`bool`型や`bool`を基底型とするenum型に対してビット演算子`~`(補数)を適用した場合、期待される結果と異なる挙動を示すケースがあることを、具体的なコード例とコンパイラの挙動を交えながら説明しています。

全文翻訳

true の補数は true、ただし false の場合を除く

最近、C++26 のアノテーションを使用して列挙型にビットマスク操作のセットを追加する提案である P4313R1 を見ました。その中心的なアイデアは、以下のようなコード例で示されるように、[[=std::bitmask_type]] アノテーションが Permission にビット単位操作のアクセス可能なセットを自動的に付与し、ユーザーが自分で記述する必要がなくなるというものです。

enum class [[=std::bitmask_type]] Permission {
  None    = 0,
  Read    = 1 << 0,
  Write   = 1 << 1,
  Execute = 1 << 2,
};

このアノテーションにより、Permission は Permission::Read | Permission::Write のような操作を直接サポートできるようになります。しかし、これは C++ における整数演算の奥深い部分について私に考えさせられました。C++ コンパイラは、組み込み操作として任意の整数型に対してビット単位演算を喜んで計算します。これは、wchar_t、UTF 文字型 char8_t から char32_t、そして bool のような、伝統的に整数とは考えない型にも及びます。しかし、実際には見た目以上に多くのことが起こっています。なぜなら、a | b のような操作を実行しようとしたときに、a と b の型が int より小さい整数型である場合、言語は a と b のビットパターンを直接操作しません。それらは整数昇格を受けます。つまり、中間状態として int に昇格され、これら 2 つの int のビットパターンが結合され、結果は依然として int として返されます。1 以下を考えてみてください。

// 2つの short 型
constexpr short perm_A {1 << 0};
constexpr short perm_B {1 << 1};

// そしてそれらのビット単位演算の結果の型は int
static_assert(std::same_as<decltype(perm_A | perm_B), int>);

ほとんどの場合、これは無害です。上記の perm_A | perm_B を short にキャストし直すと、不要なバイトは切り捨てられ、perm_A と perm_B を short として直接結合した場合と同じ値を持つ short が残ります。また、型の整合性を確実に保ち、サイレントな狭窄変換の有害なバグを回避したい場合は、ビット単位演算の結果を元の型に static_cast する習慣を身につけることができます。しかし、ここで重要なのは、整数昇格はオプションではないということです。C++ の他のほとんどの領域とは異なり、開発者は選択の余地がありません。これらの操作のために、型は避けなく昇格されます。

bool にとってこれが危険である第二の理由は、ブーリアン変換です。これは切り捨てを行わず、代わりにゼロを false に、非ゼロ値を true に明示的に変換します。これらの非ゼロ値については、以前に格納されていたビットパターンは破棄され、整数値 1 を持つ true に置き換えられます。したがって、次のようなコードを考えてみましょう。

int x{10};
bool b{static_cast<bool>(x)};

生成されたアセンブリ(この場合は最適化されていない x86-64 gcc 16.2 から)を見ると、次のようになります。

mov     DWORD PTR [rbp-4], 10   ; 10 の値を格納
cmp     DWORD PTR [rbp-4], 0    ; 次に 0 と比較、x がゼロなら ZF を設定
setne   al                      ; ZF がクリアなら AL に 1 を書き込む
mov     BYTE PTR [rbp-5], al    ; 結果を格納

標準(特に conv.bool)は、bool が保持できる唯一の値である true と false に基づいて bool への変換を行います。元のビットパターンが何であれ関係ありません。したがって、~true を評価してから結果を bool にキャストした場合に何が起こるかを考えてみましょう。

  • 値 true は整数 1 に昇格されます。
  • C++20 以降、2 の補数動作が要求されるため、整数 1 の補数は -2 として計算されます。
  • 値 -2 は bool にキャストされ、ブーリアン変換を受けます。-2 は非ゼロなので、true になります。

これで、true の補数は true であることがわかりました。C++ では static_cast<bool>(~true) == true となります。

これが列挙型に戻ってきます。列挙型は、bool を含む任意の整数型を基底型として使用することが許可されています。では、定義してみましょう。

enum class [[=std::bitmask_type]] boolean : bool{
    FALSE,
    TRUE,
};

P4313R1 に記載されているビット単位補数演算子を見てみましょう。

template<bitmask-like T> constexpr T operator~ (T lhs) noexcept {
  return static_cast<T>(~to_underlying(lhs));
}

この演算子の動作は、今や見慣れた形になっているはずです。まず、列挙型を基底型(この場合は bool)に変換し、次にその型が int よりランクが低い場合は整数昇格が適用され、ビット単位演算を実行し、最後に列挙型にキャストバックします。予想通りです。

static_assert(~boolean::TRUE == boolean::TRUE);

Godbolt こちら。

これは、言語における少し混乱を招くコーナーケースとなる可能性があります。

ここに 1 つの例外的なケースがあり、問題がさらに複雑になります。もし私たちが同じ例を gcc で実行しようとすると、異なる結果が得られます。

static_assert(~boolean::TRUE == boolean::FALSE);

Godbolt こちら。

gcc で何が起こっているのでしょうか? 操作をランタイムに移動するために、それに依存する 2 つの関数を定義してみましょう。

enum class boolean : bool{
    FALSE,
    TRUE,
};

void f(int x, bool& out) {
    out = static_cast<bool>(x);
}

void g(int x, boolean& out) {
    out = static_cast<boolean>(x);
}

そしてアセンブリ(これも最適化されていない x86-64)を見ると、次のようになります。

"f(int, bool&)":
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], edi
        mov     QWORD PTR [rbp-16], rsi
        cmp     DWORD PTR [rbp-4], 0
        setne   dl                          ; 前述の [conv.bool] と同じ setne パターン
        mov     rax, QWORD PTR [rbp-16]
        mov     BYTE PTR [rax], dl
        nop
        pop     rbp
        ret
"g(int, boolean&)":
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], edi
        mov     QWORD PTR [rbp-16], rsi
        mov     eax, DWORD PTR [rbp-4]
        and     eax, 1                      ; 最下位ビットを eax に格納
        mov     rdx, QWORD PTR [rbp-16]
        mov     BYTE PTR [rdx], al          ; そして al を out-param に移動
        nop
        pop     rbp
        ret

ここでわかるのは、型が bool と明記されていない場合、gcc はブーリアン変換を実行する代わりに、最下位ビットに切り捨てるということです。偶数の値はキャスト時に boolean::FALSE を生成し、奇数の値は boolean::TRUE を生成します。

これは列挙型に特有のもので、gcc は通常、bool を直接扱う際には一貫した動作をします。

constexpr boolean b{boolean::TRUE};
static_assert(static_cast<bool>(~b) == false);

static_assert(static_cast<bool>(~true) == true);

static_assert(std::to_underlying(~b) == false);

static_assert(static_cast<bool>(~std::to_underlying(b)) == true);

これら 4 つの補数とキャストの組み合わせすべてを Clang と MSVC は true として評価しますが、これは標準が要求することです。完全な Godbolt 比較は こちら です。これは gcc におけるかなり長期間にわたる準拠バグのようです。

しかし、標準の 1 つの箇所では、整数昇格のルールがさらに進み、これらのビットマスク操作を行う際にプログラムに未定義動作(UB)が入り込む新しい経路を導入しています。このコードを考えてみましょう。

enum nums{
    zero,
    one,
    two,
    three,
};

// これは実装定義ですが、gcc と Clang では成り立ちます。
static_assert(std::is_same_v<std::underlying_type_t<nums>, unsigned int>);

// nums は unsigned int を基底として使用するため、表現可能な値の全範囲は >= 0 です。
// では、これをテストしてみましょう。
static_assert(~one >= 0); // 失敗します

Godbolt こちら。

診断を見ると、gcc は次のように表示されます。

<source>:15:20: error: static assertion failed
   15 | static_assert(~one >= 0); //FAILS
      |               ~~~~~^~~~
  • the comparison reduces to '(-2 >= 0)'

ここで何が起こったのでしょうか? 標準の整数昇格をカバーする箇所 conv.prom は、基底型が明示されていないスコープなし列挙型が、昇格時に通常の整数型とは異なる動作をする特別な項目を設けています。もし値の全範囲が int に格納できるなら、それが昇格される型になります。次に unsigned int を試み、それが失敗した場合は、long と long long に対してこの符号付き・符号なしのパターンを繰り返して適切な型を見つけます。しかし、これは通常の整数型とは異なり、表現可能な値の有効な範囲のみを考慮します。そのため、unsigned int でバックアップされた列挙型は、整数型では禁止される通常の変換順位に関わらず、int に昇格します。前述のように、~one を介して組み込み演算子を呼び出すと、int に昇格され、その補数が計算されて -2 となり、次に 2 つの int 間で比較が行われ、失敗します。代わりに基底型に変換すると、非対称性が実際にわかります。static_assert(~std::to_underlying(one) >= 0); は成功し、gcc が冗長だと警告するほど自明に真となります。

しかし、これは戦いの半分に過ぎず、ビット単位演算の結果を列挙型にキャストし直すことについて話す必要があります。そして、ここに UB が忍び込みます。基底型が指定されていないスコープなし列挙型は、コンパイラが実際にバックアップに使用する型が何であれ、その表現可能な値の範囲とは独立して、列挙子によって決定される有効な値の範囲という点で自身を定義します。dcl.enum は、そのような列挙型の値の範囲は、すべての列挙子を表現するために必要な最小ビット数 M の仮説的な整数型の値の範囲であると述べています。例を示すために、いくつかの例を考えてみましょう。

enum small{ // 列挙子の範囲は 0..1 なので、値の範囲は 1 ビットの符号なし整数です。
    a = 0,
    b = 1,
};

enum medium{ // 列挙子の範囲は 0..7 なので、値の範囲は 3 ビットの符号なし整数です。
    c = 0,
    d = 4,
    e = 7
};

enum large{ // 列挙子の範囲は -1..100 なので、値の範囲は 8 ビットの符号付き整数です。
    f = -1,
    g = 10,
    h = 100,
};

コンパイラはおそらくこれらの列挙型を unsigned int や int として格納するでしょうが、表現可能な値のサブセットのみが有効です。それは M ビット整数の値の範囲です。expr.static.cast は、その範囲外の値を列挙型にキャストすることは未定義動作であることを明確にしています。したがって、上記の例の列挙子を使用すると、次のようになります。

static_cast<small>(1); // 定義済み
static_cast<small>(2); // UB

static_cast<medium>(3); // 定義済み: 列挙子の値ではありませんが、3 ビットの符号なし整数の範囲内です。
static_cast<medium>(8); // UB

static_cast<large>(-128); // 定義済み
static_cast<large>(128); // UB

これが危険地帯です。ビット単位演算子、特に operator~ は、列挙型の有効な値の範囲外の値を生み出す可能性があり、この値を列挙型にキャストし直そうとするユーザー定義演算子は UB を引き起こす可能性があります。

しかし、あなたは叫ぶでしょうが、先ほどの ~one の例はどうなったのでしょうか? 値 -2 が得られ、これは nums の値の範囲外でした。これは真実ですが、ここで整数昇格が私たちを救ってくれます。one は補数を計算する前に int に昇格され、UB を引き起こすためにダウンキャストされることはありませんでした。ユーザー定義演算子が演算の結果を元の列挙型にキャストバックする場合にのみ、危険な領域に入ります。

また、この UB リスクは、基底型が指定されていないスコープなしの「プレーン」列挙型にのみ適用されることに注意することが重要です。すべてのスコープ付き列挙型は、明示的に指定されていなくても(その場合 int)、固定の基底型を持ちます。また、固定の基底型を指定するすべてのスコープなし enum 型は、独自の型を生成する代わりに、その型の値の範囲を継承します。

あなた自身のコードでこれを回避する方法

P4313 のように、列挙型にビットマスク操作を追加するとしましょう。この領域の奇妙さがさらに増した今、コードが正しく、混乱を招かないようにするにはどうすればよいでしょうか? bool のケースを回避するのは簡単です。基底型が bool になれないように制約します。これはすべての列挙型に対して、または補数演算子に対して行うことができます。しかし、標準には、基底型が指定されていないスコープなし列挙型を特別に検出する便利な型特性やリフレクションメタ関数が付属していません。幸いなことに、私たちはそれを作成できます。

template<typename E>
concept unfixed_enum = std::is_enum_v<E> && !requires { E{0}; };

dcl.init.list は、スカラーからのこの初期化を、固定基底型を持つ列挙型にのみ許可しており、0 はすべての可能な列挙型で表現可能な唯一の値です。エッジケースをカバーするために、標準は列挙子を持たない列挙型を、符号なし 1 ビット整数の値の範囲を持つものと定義しています。そして、1 を除外するものは enum E{ a = -1 }; で、範囲は [-1, 0] です。std::is_enum_v を忘れないでください。結局のところ、T{0} が不正な型は数多くあり、そのほとんどは列挙型ではありません。

この投稿は主にビット単位補数演算子に焦点を当てていましたが、基底型が指定されていない列挙型の UB トラップは、ビット単位左シフト演算子にも適用されます。操作ごとに制約する道を選ぶなら、それを忘れないでください。

これで P4313R1 に戻ります。執筆時点では、これらの演算子を制約するコンセプトは、型を [[=std::bitmask_type]] でアノテートされた列挙型のみに制約しています。そのため、bool でバックアップされた列挙型に対する混乱を招く動作や、基底型が指定されていないプレーンな列挙型に対する潜在的な UB を許容します。もし著者が上記の初期化リストのトリックを標準化したいのであれば、保守的なアプローチとして std::is_scoped_enum で制約することで UB への容易なアクセスを防ぐことができます。なぜなら、スコープなし列挙型はすべて(結果が int になるとしても)組み込みビット単位演算子を使用できるからです。また、混乱を最小限に抑えるために、基底型が bool でないように制約することもできます。特に、ユーザーコードで bool を補数化した場合に通常発行される診断は、システムヘッダーからのものである場合、デフォルトで抑制されるためです。著者にこれらの制約をペーパーに追加したいかどうかを確認するために、P4313 の著者たちに連絡するつもりです。

余談: 浮動小数点数はどうなるか?

浮動小数点数をこれらの bool バックアップ列挙型に変換する方法について、標準がどのように定義しているか疑問に思うかもしれません。それはおそらく驚くことではありません。expr.static.cast は、動作が浮動小数点値を列挙型の基底型に変換し、次にそれを列挙型に変換するのと同等であることを要求しています。これはユーザーを conv.fpint に誘導し、そこには私たちの古い友人である [conv.bool] に直接言及する注記があります。標準によれば、これは 0.0 または -0.0 以外の任意の浮動小数点値は boolean::TRUE に変換され、それ以外の場合は boolean::FALSE になることを意味するはずです。

では、小さく始めてみましょう。

enum class boolean : bool {
    FALSE,
    TRUE,
};

static_assert(static_cast<boolean>(0.0) == boolean::FALSE);
static_assert(static_cast<boolean>(0.5) == boolean::TRUE);
static_assert(static_cast<boolean>(2.5) == boolean::TRUE);

Godbolt こちら。

Clang と gcc は両方ともこのコードを拒否します。エラーは (boolean)2.5e+0 が定数式ではないこと、そして static_cast<boolean>(0.5) == boolean::TRUE が間違っており、代わりに boolean::FALSE に等しいということです。MSVC は上記のコードを受け入れます。

しかし、さらに進んで、実際に格納されているものを調べてみましょう。これらのキャストから生成されたビットパターンを検査する関数を書き、いくつかの値を試してみます。

void show(double d) {
    const boolean e = static_cast<boolean>(d);
    unsigned char byte {};
    std::memcpy(&byte, &e, 1);
    std::println("static_cast<boolean>({:7.1f})  stored byte {:3}   required {}",
               d, byte, (d != 0.0) ? 1 : 0);
}

int main() {
    show(0.0);
    show(0.5);
    show(1.0);
    show(2.5);
    show(3.0);
    show(256.0);
    show(-2.5);
}

Godbolt こちら。

上記のコードはすべてのコンパイラで警告なしにコンパイルされますが、MSVC は常に正しいことを行う一方で、gcc と Clang の動作ははるかに懸念されます。出力を調べると、gcc は常に値を整数に切り捨て、そのビットパターンを結果の boolean にロードすることがわかります。したがって、2.5 は 2 に切り捨てられ、ビットパターンが 2 である boolean が生成されます。Clang は最適化されていないビルドでは同じことを行いますが、最適化が有効になると、切り捨てられた値は通常の [conv.bool] 変換を経て、範囲 (-1, 1) 外のすべての非ゼロ値に対して正しい結果を生成します。

しかし、これは奇妙なビットパターンよりもさらに懸念されることです。boolean の有効な範囲は [0, 1] です。この範囲外のビットパターンを持つオブジェクトを読むことは UB です。しかし、これらの boolean を bool にキャストして、初期浮動小数点状態なしのブーリアン変換をトリガーするとどうなるでしょうか? MSVC は再び正しいことを行います。gcc はビットパターンを変更せず、型の範囲外の bool が残ります(したがって読むことは UB です)。そして Clang では、再びお楽しみが起こります。上記のコードを e から bool へのキャストを実行し、その bool を unsigned char に memcpy する場合、最適化されていないビルドでは次の結果が得られます。

0.00.51.02.53.0256.0-2.5
required0111111
gcc 14 / 15 / 16001230254
clang 19 / 20 / 210010100
clang 23.1.10011101

Clang 23 より前のバージョンは、単に trunc(d) & 1 を実行しているようです。つまり、切り捨て後、奇数は true、偶数は false になります。Clang 23 は (trunc(d) % 256) != 0 を実行し、まずバイトに狭めます。したがって、256.0 は FALSE になり、257.0 は TRUE になります。最適化されたビルドは以前と同様に動作します。つまり、切り捨ててから適切なブーリアン変換を行います。

最終的に、これはすべて非常にばかげた結末を迎えます。以下のコードを考えてみましょう。

#include <print>

enum class boolean : bool {
    FALSE,
    TRUE,
};

// これをランタイムに強制する
boolean make(double d) {
    return static_cast<boolean>(d);
}

int main() {
    const boolean e = make(2.5);
    std::println("e == boolean::TRUE  : {}", e == boolean::TRUE);
    std::println("e == boolean::FALSE : {}", e == boolean::FALSE);

    const bool b = static_cast<bool>(e);
    std::println("b == true  : {}", b == true);
    std::println("b == false : {}", b == false);
    std::println("b + 0      : {}", b + 0);
}

Godbolt こちら。

MSVC は再び正しい答えを出すという点で先頭に立ちます。Clang はそれを完全に間違え、e が FALSE で b が false であると考えます。gcc はさらに一歩進んで、列挙子のすべてと等価な比較を行う列挙型のインスタンスと、true でも false でもない bool を提供しますが、オプティマイザーをオンにすると、true でもあり false でもある bool になります。

そして、浮動小数点に関するあらゆる会話の義務的なターゲットをすべてヒットするために、無限大と NaN は gcc と Clang では 0 として表示され boolean として FALSE になり、bool として false にキャストされます。MSVC では 1、したがって TRUE と true になります。

明るいニュースとしては、Clang trunk は上記の例を正しく動作するように修正したようです。そのため、このセクションで説明されている問題の一部はまもなく修正されるでしょう。

結論

ここから何を学びましたか? おそらく、P4313 のような、まともで議論の余地のない純粋なライブラリレベルのペーパーでさえ、エキゾチックな C++ のエッジケースからの落とし穴に注意する必要があるということです。あるいは、より実用的な言葉で言えば:

  • 整数昇格は避けられません。int より小さい整数を操作していると思っても、それはあなたの知らないうちに int になっていた可能性が高いです。
  • bool のビット単位補数は、列挙型にラップされていても、常に true です。ただし、gcc にはこの動作を間違える(または論理を C++ に合わせるなら正しい)長年のバグがあるため、この動作に依存すべきではありません。
  • 基底型が指定されていないスコープなし列挙型は、実際にそれをバックアップしている型よりも小さい有効な値の範囲を持つことがあります。

  1. 明確にするために、整数昇格の順位は単に「int に変換する」よりも複雑です。int より変換ランク(サイズではない)が低い整数型の場合、その型のすべての値が int で表現できるなら int が選択されます。そうでない場合は unsigned int が選択されます。実際にはこれは通常 int になります。しかし、int と short が同じサイズである実装では、unsigned short は直接 unsigned int に昇格します。また、charN_t ファミリのような他の型では、long や long long のようなより長い整数型への変換が行われることがあります。bool は特別なケースとして区別され、常に int に昇格します。↩︎