C++
不特定の動作

備考

TU全体のグローバルの初期化の順序

翻訳単位内では、グローバル変数の初期化の順序が指定されていますが、翻訳単位の初期化の順序は不特定です。

次のファイルを持つプログラム

• foo.cpp

  #include <iostream>
  
  int dummyFoo = ((std::cout << "foo"), 0);
  

• bar.cpp

  #include <iostream>
  
  int dummyBar = ((std::cout << "bar"), 0);
  

• main.cpp

  int main() {}
  

出力として生成される可能性があります：

foobar

または

barfoo

スタティック・イニシアチブ・オーダー・フィアスコにつながる可能性があります。

範囲外列挙型の値

スコープ付き列挙型が値を保持するには小さすぎる整数型に変換された場合、結果の値は指定されません。例：

enum class E {
    X = 1,
    Y = 1000,
};
// assume 1000 does not fit into a char
char c1 = static_cast<char>(E::X); // c1 is 1
char c2 = static_cast<char>(E::Y); // c2 has an unspecified value

また、整数が列挙型に変換され、整数の値が列挙型の値の範囲外にある場合、結果の値は指定されません。例：

enum Color {
    RED = 1,
    GREEN = 2,
    BLUE = 3,
};
Color c = static_cast<Color>(4);

ただし、次の例では、ソース値がすべての列挙子と等しくないにもかかわらず、列挙型の範囲内にあるため、振る舞いは未定義ではありません 。

enum Scale {
    ONE = 1,
    TWO = 2,
    FOUR = 4,
};
Scale s = static_cast<Scale>(3);

ここでs値3を持っている、との不平等になるONE 、 TWO 、およびFOUR 。

偽のvoid * valueからの静的キャスト

場合void*値は、タイプ、オブジェクトへのポインタに変換され、 T* 、しかし適切に位置合わせされていないT 、得られたポインタ値は不定です。例：

// Suppose that alignof(int) is 4
int x = 42;
void* p1 = &x;
// Do some pointer arithmetic...
void* p2 = static_cast<char*>(p1) + 2;
int* p3 = static_cast<int*>(p2);

p2はint型のオブジェクトを指すことができないため、 p3の値は未定義です。その値は正しく整列されたアドレスではありません。

いくつかのreinterpret_cast変換の結果

1つの関数ポインタ型から別の関数型へのreinterpret_cast、またはある関数参照型から別の関数型へのreinterpret_castの結果は指定されていません。例：

int f();
auto fp = reinterpret_cast<int(*)(int)>(&f); // fp has unspecified value

int x = 42;
char* p = reinterpret_cast<char*>(&x); // p has unspecified value

いくつかのポインタ比較の結果

< 、 > 、 <= 、または>=を使用して2つのポインタを比較すると、結果は次の場合には指定されません。

• ポインターは異なる配列を指します。 （非配列オブジェクトはサイズ1の配列と見なされます）

  int x;
  int y;
  const bool b1 = &x < &y;            // unspecified
  int a[10];
  const bool b2 = &a[0] < &a[1];      // true
  const bool b3 = &a[0] < &x;         // unspecified
  const bool b4 = (a + 9) < (a + 10); // true
                                      // note: a+10 points past the end of the array
  

• ポインターは同じオブジェクトを指しますが、アクセス制御の異なるメンバーにポイントします。

  class A {
    public:
      int x;
      int y;
      bool f1() { return &x < &y; } // true; x comes before y
      bool f2() { return &x < &z; } // unspecified
    private:
      int z;
  };
  

リファレンスが占めるスペース

参照はオブジェクトではなく、オブジェクトとは異なり、連続したいくつかのメモリバイトを占有することは保証されていません。標準では、リファレンスがストレージを必要とするかどうかは不明です。言語の多くの機能は、参照が占める可能性のある記憶域を移植可能に調べることを不可能にしています。

• sizeofが参照に適用される場合、参照される型のサイズが返されるため、参照が格納領域を占有しているかどうかに関する情報は提供されません。
• 参照の配列は不正です。したがって、配列の仮想参照の2つの連続した要素のアドレスを調べて、参照のサイズを判断することはできません。
• 参照のアドレスが取られた場合、結果は参照先のアドレスになるので、参照自体へのポインタを取得することはできません。
• クラスに参照メンバがある場合、 offsetofを使用してそのメンバのアドレスを抽出しようとすると、標準レイアウトクラスではないため、未定義の動作が発生します。
• クラスに参照メンバーがある場合、そのクラスはもはや標準レイアウトではないため、参照を格納するために使用されるデータにアクセスしようとすると、未定義または未指定の動作が発生します。

実際には、場合によっては、ポインタ変数と同様に参照変数を実装することができ、したがってポインタと同じ量の記憶域を占有することがありますが、参照が最適化できるため、参照は全くスペースを占有しません。たとえば、次のようになります。

void f() {
    int x;
    int& r = x;
    // do something with r
}

コンパイラは、単に治療に自由であるr別名としてxとのすべての出現置き換えるr 、関数の残りの部分でfとx 、および保持するために、任意のストレージ割り当てませr 。

関数の引数の評価順序

関数が複数の引数を持つ場合、評価される順序は不特定です。次のコードはx = 1, y = 2またはx = 2, y = 1を出力できますが、

int f(int x, int y) {
    printf("x = %d, y = %d\n", x, y);
}
int get_val() {
    static int x = 0;
    return ++x;
}
int main() {
    f(get_val(), get_val());
}

struct from_int {
  from_int(int x) { std::cout << "from_int (" << x << ")\n"; }
};
int make_int(int x){ std::cout << "make_int (" << x << ")\n"; return x; }


void foo(from_int a, from_int b) {
}
void bar(from_int a, from_int b) {
}

auto which_func(bool b){
  std::cout << b?"foo":"bar" << "\n";
  return b?foo:bar;
}

int main(int argc, char const*const* argv) {
  which_func( true )( make_int(1), make_int(2) );
}

bar
make_int(1)
from_int(1)
make_int(2)
from_int(2)

bar
make_int(2)
from_int(2)
make_int(1)
from_int(1)

bar
make_int(2)
make_int(1)
from_int(2)
from_int(1)

最も標準的なライブラリクラスの移動状態

int main() {
    std::vector<int> v1{1, 2, 3, 4};
    std::vector<int> v2 = std::move(v1);
}