************************************* エラーおよび警告メッセージファイル ************************************* このファイルには、Sun ANSI C++ コンパイラ (ccfe) のエラーおよび警告メッセージが含まれます。オプティマイザ、 コードジェネレータ、リンカーといった、CC ドライバのその他のコンポーネントから発行されるメッセージは含まれません メッセージの形式は以下のとおりです。 o メッセージ o 説明 o メッセージを生成するコードの例 o メッセージ ID (タグ) 説明やコード例は、すべてのメッセージに記述されているわけではありません。 コンパイラメッセージには、次の 2 種類があります。 o 警告メッセージ - ファイル名と行番号に続いて "警告" の文字が表示され、 コンパイルを中断することなく、役に立つ情報を提供します。 コンパイラが有効なオブジェクトコードを生成できない原因となるプログラミングの誤りや C++ の構文や意味上の違反を診断します。 o エラーメッセージ - "エラー" の文字で始まります。コンパイラコマンドは失敗します。 プログラムの理解や正常なオブジェクトコードの生成を妨げるような深刻な問題をコンパイラが診断したときに、 エラーとなります。ただし、コンパイラはプログラムの残りについても他にエラーがないかどうかを調べます。 エラーが診断されたときは、コンパイラはプログラムのリンクは行いません。 メッセージの前に "起きるはずのない内部エラー" という語句がある場合、 通常はプログラミングの誤りではなく、コンパイラの問題が診断されています。 コンパイラの内部整合性検査の 1 つが失敗しています。 発行されるメッセージによって診断される問題は重要です。以下の手順で問題の識別にご協力ください。 1. 失敗したときと同じオプションに -P オプションを追加して、もう一度 CC コマンドを実行します。 出力は現在のディレクトリ内に .i 接尾辞を持つファイルとして置かれます。このファイルは、 コンパイラの問題を識別するのに役立ちます。 2. ご購入先担当者にご連絡ください。 *************************************

## 起きるはずのない内部エラー

このメッセージは、コンパイラの内部エラーが発生した場合に表示されます。 エラーの状況をまとめご購入先に連絡してください。

メッセージ ID: noerror

## 整数のオーバーフローが検出されました

コンパイル時に浮動小数点の加算が試みられ、結果がオーバーフローすると診断されました。結果の下位 32 ビットが保持されます。

メッセージ ID: addfovfl

## 整数のオーバーフローが検出されました

コンパイル時に加算が試みられ、結果がオーバーフローすると診断されました。結果の下位 32 ビットが保持されます。

メッセージ ID: addovfl

## 使用した後、再定義しています

クラスがすでにスコープ外で定義した名前を使用しており、 その名前を再定義することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    typedef int Integer;

    class A {
      Integer i;
      float Integer; //エラー: A で使用した後、Integer を再定義している
    };

メッセージ ID: alreadyusedc

## 使用した後、テンプレートを再定義しています

そのテンプレートはすでにローカルに使用されており、再定義することはできません。 この警告メッセージを生成するコードの例を次に示します。

    template <class T>
    class A{};

    class B {
    	A<int> a1;
    	float A; // 警告
    };

    template
    class C {
    	A a2;
    	long A;
    };
    C<int> ac; // 警告

メッセージ ID: alreadyusedt

## 名前があいまいです

その名前は、両方の基底クラスに存在します。スコープ演算子を使用してどちらか一方を指定してください。 このエラーメッセージを生成するコードの例を次に示します。

    struct A {
            int i;
    };

    struct A2 {
            int i;
    };

    struct B: A, A2 {
            B() { i = 7; }
    	// エラー: 名前 i が B: A::i および A2::i であいまい
    };

メッセージ ID: ambigfield

## 基底クラスがあいまいです

その基底クラスは、あるクラスの 2 つ以上の基底クラスに組み込まれています。 どれか 1 つを指定する必要があります。 このエラーメッセージを生成するコードの例を次に示します。

    struct B { int i; };

    struct B1: B {
      int j;
    };

    struct B2: B {
      int j;
    };

    struct A: B1, B2 {
      A() {
        i = 7; // エラー: B::i であいまい
        B1::i = 7; // ok
        B2::i = 7; // ok
      }
    };

メッセージ ID: ambigbfield

## 基底クラスがあいまいです

基底クラスがあいまいです。すでに 1 つ以上の基底クラスに組み込まれています。 このエラーメッセージを生成するコードの例を次に示します。

    struct A {
      int i;
    };

    struct B: A {
      int j;
    };

    struct C: A, B {
      int k;
      void foo() {
    	A::i = 10; // エラー: 基底クラス A が C であいまい
      };
    };

メッセージ ID: ambigbspec

## 名前があいまいです

同じ名前が 2 つ以上の基底クラスで見つかりました。どれか 1 つを指定してください。 このエラーメッセージを生成するコードの例を次に示します。

    struct B1 {
      void foo(){}
    };

    struct B2 {
      void foo(){}
    };

    struct A: B1, B2 {
        int i;
    };

    void bar()
    {
      A a;
      a.foo(); // エラー
      a.B1::foo(); // ok
      a.B2::foo(); // ok
    }

メッセージ ID: ambigname

## 無名の共用体は関数のメンバーを持つことはできません

無名の共用体は関数のメンバーを持つことはできません。 このエラーメッセージを生成するコードの例を次に示します。

    static union {
            void foo(){} // エラー
    };

メッセージ ID: anonnofunc

## 無名の共用体は非公開メンバーおよび限定公開メンバーを持つことはできません

無名の共用体は非公開メンバーおよび限定公開メンバーを持つことはできません。 このエラーメッセージを生成するコードの例を次に示します。

    static union {
            long j;

            private:
            	int i; // エラー
    };

メッセージ ID: anonnoprivate

## 大域的な無名の共用体は静的でなければなりません

大域的な無名の共用体は静的でなければなりません。このエラーメッセージを生成するコードの例:

    union { // エラー
            long i;
            int j;
    	float k;
    };

メッセージ ID: anonnotstatic

## 共用体のメンバーはユーザー定義の代入演算子を持つことはできません

共用体のメンバーがユーザー定義の代入演算子を持つことは不当です。このエラーメッセージを生成するコードの例:

    class A {
    public:
      int i;
      A &operator =(A &la);
    };

    union B {
      A a;
      int i;
    };

メッセージ ID: asgnotall

## 〜には参照メンバーがあるため、代入することはできません

クラスには参照メンバーがあります。このようなクラスのインスタンスには代入できません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    public:
      int &i;
      int j;
      A(): i(j), j(5) {}
    };

    void foo()
    {
      A a1;
      A a2;
      a1 = a2; // エラー: インスタンス a1 の参照メンバー i には代入できない
    }

メッセージ ID: asgwref

## 〜には const のメンバーがあるため、代入することはできません

このメンバーは宣言済みの const であり、値を代入することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    public:
      const int i;
      A(): i(5) {}
    };

    void foo()
    {
      A a1;
      A a2;
      a1 = a2; // エラー: インスタンス a1 の const メンバー i には代入できない
    }

メッセージ ID: asgwconst

## 宣言なしのテンプレートとして使用しています

テンプレートは初めに宣言する必要があります。 この警告メッセージを生成するコードの例を次に示します。

    template class B<int>; // 警告: B が宣言されてない

メッセージ ID: assumetemp

## アクセスを変更できません

メンバーに対するアクセスをこの方法では変更できません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
     protected:
       int i;
    };

    class B : public A {
       public:
         A::i;  // エラー:   アクセスを変更できない
    };

メッセージ ID: badaccadj

## 〜のためアクセスを変更することはできません

別のクラスメンバーが存在するため、アクセスを変更できません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
     public:
         int i;
    };

    class B : public A {
       protected:
         int i;
       public:
         A::i;  // エラー: B::i があるため、A::i のアクセスは変更できない
    };

メッセージ ID: badadjname

## 演算が不当です

このオブジェクトには単項演算子が定義されていません。このエラーを修正するには、渡される型に多重定義された単項演算子を定義します。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    	int i;
    public:
    	//演算子 ++(); // 前置演算子 ++
    };

    void foo()
    {
    	A a;
    	a++; // エラー: 演算子 ++ を多重定義して修正する
    }

メッセージ ID: badtunaryop

## 演算が不当です

このオブジェクトには 2 項演算が定義されていません。このエラーを修正するには、2 項演算子を多重定義して、渡される引数を受け付けます。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
       int i;
    };

    void foo()
    {
       A a, b;
       int i = a + b; // エラー
       int j = a%b;	// エラー
    }

    void bar() {
      int i = 9;
      float j = -9.3;
      i % j; // エラー
    }

メッセージ ID: badbinaryop

## 〜型の仮引数は左辺値を必要とします

参照を受け付ける関数に左辺値以外が渡されました。 このエラーメッセージを生成するコードの例を次に示します。

    int foo( int &i)
    {
      i = foo(1); // エラー:"1" は左辺値ではない

     return 2;
    }

メッセージ ID: badarglval

## 呼び出し中の型の仮引数は左辺値を必要とします

ポインタまたはアドレスを受け付ける関数に左辺値以外が渡されました。 このエラーメッセージを生成するコードの例を次に示します。

    int foo( int &i)
    {
      i = foo(1); // エラー:"1" は左辺値ではない
     return 2;
    }

メッセージ ID: badarglval2

## 〜型の仮引数が〜に渡されています

関数に渡されている引数は、この関数のパラメータに代入できません。 このエラーメッセージを生成するコードの例を次に示します。

    void foo(int *cp);

    int main() {
      const char *cp = "abcd";
      foo(cp); // エラー: const char *cp が int* に渡されている
    return 0;
    }

メッセージ ID: badargtype

## 呼び出しにおいて型の仮引数が渡されています

関数呼び出しにおける仮引数を関数のパラメータに代入できません。 このエラーメッセージを生成するコードの例を次に示します。

    void foo(int *cp);

    int main() {
      const char *cp = "Hello";
      foo(cp); // エラー: const char *cp が int* に渡されている
    return 0;
    }

メッセージ ID: badargtype2

## 〜型の仮引数が〜に渡されています

関数呼び出し中の仮引数の型がこの関数のパラメータに一致しません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    public:
      int i;
      A() { i = 1; };
    };

    void foo(A *Ap);

    int main() {
      const A *Ap = new A();
      foo(Ap); // エラー: 引数の型 A* が const A* に渡されている
    return 0;
    }

メッセージ ID: badargtypew

## 仮引数で文字列リテラルを char* に変換しました

関数呼び出し中の仮引数の型が関数のパラメータと一致しません。 この警告メッセージを生成するコードの例を次に示します。

    void foobar(char *c);

    void foo()
    {
    	const char *c = "abcde";
    	foobar(c); // 警告: foobar の呼び出し中の char* が const char* に渡されている
    }

メッセージ ID: badargtypelw

## 呼び出しにおいて型の仮引数が渡されています

関数呼び出し中の仮引数の型が関数のパラメータと一致しません。 この警告メッセージを生成するコードの例を次に示します。

    class A {
    public:
      int i;
      A() { i = 1; };
    };

    void foo(A *Ap);

    int main() {
      const A *Ap = new A();
      foo(Ap); // 警告: 引数の型 A* が const A* に渡されている
    return 0;
    }

メッセージ ID: badargtype2w

## 呼び出し中の仮引数で文字列リテラルを char* に変換しました

関数呼び出し中の仮引数の型が関数のパラメータと一致しません。

メッセージ ID: badargtypel2w

## 配列初期設定子の周辺の括弧が不当です

配列初期設定子は "{" と "}" で囲む必要があります。 この警告メッセージを生成するコードの例を次に示します。

    static char a [5] = ("qwer");

メッセージ ID: badarrinit

## この条件では型〜は使用できません

構文エラーの検出: 条件の型が不正です。 このエラーメッセージを生成するコードの例を次に示します。

    void foo() {
       for ( ;int i[1] = (1); );    // エラー: この条件では型 int[1] は使用できない
    };

メッセージ ID: badcondtype

## 型の仮引数にアクセス不能なコピーコンストラクタがあります

型にアクセス不能なコンストラクタがあります。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
      A(A& a) { };  // ユーザー定義の非公開のコピーコンストラクタ
     public:
      A() {};
    };

    A the_a;

    void foo(A a) { };

    void bar() { foo(the_a); }; // エラー: foo(A) の呼び出し中の型 A の仮引数に
                                // アクセス不能なコピーコンストラクタがある

メッセージ ID: badcopyacc

## 〜への呼び出しにおいて型の仮引数にアクセス不能なコピーコンストラクタがあります

関数呼び出し内の仮引数のオブジェクト型に、アクセス可能なコピーコンストラクタがありません。この仮引数は新しいオブジェクトにコピーできません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
      	A(A &a); // ユーザー定義の非公開のコピーコンストラクタ
        public:
    	A();
    	void foo(A a);
    } a1, a2;

    int main() {
      a2.foo(a1); // エラー: A(A&) は非公開
    };

メッセージ ID: badcopyacc2

## 配列には少なくとも 1 つの要素がなければなりません

配列の宣言でサイズはゼロまたは負にできません。 このエラーメッセージを生成するコードの例を次に示します。

    int ia[-5];
    int ib[0];

メッセージ ID: badarraysize

## 演算が不当です

オブジェクトの型が配列型ではないため配列演算子を使用することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    public:
      //A operator[] (int);
    } a1, a2, a3[4];

    int main() {
      a1[7] = a2; // エラー: a1 は配列ではない
      a3[4] = a2; // ok
    };

メッセージ ID: badarraytype

## 〜を〜に代入することはできません

互換性のない型にオブジェクトが代入されています。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
      int i;
    };

    void foo()
    {
      A a;
      int j;
      j = a; // エラー: int に A を代入できない
    }

メッセージ ID: badassignment

## operator= なしでは代入できません

明示的な代入演算子を指定する必要があります。 このエラーメッセージを生成するコードの例を次に示します。

    class A { };

    class B {
        public:
            int operator = (int ) { return 0; }
            // エラーメッセージを除去するには次の演算子を
            // 定義する必要がある:
            // int operator = (const A&);
    };

    int main () {
        A a;
        B b;

        b = a;
    }

メッセージ ID: badasscasg

## 基底〜は以前に定義されたクラスまたは構造体でなければなりません

指定された基底クラスは定義済みのクラスまたは構造体ではありません。 このエラーメッセージを生成するコードの例を次に示します。

    class B;

    class A: B {}; // エラー: 基底 "B" が定義されていない。

メッセージ ID: badbaseclass

## ビットフィールドは整数の型でなければなりません

整数型でないビットフィールドを指定することは不当です。 このエラーメッセージを生成するコードの例を次に示します。

    static union {
        float c:3; //エラー
    };

メッセージ ID: badbftype

## この break はループの中にも switch の中にもありません

`break` 文は、`loop` 文中または `switch` 文中以外には指定できません。 このエラーメッセージを生成するコードの例を次に示します。

    int main()
    {
    	int i = 5;

    	break;

    return 0;
    }

メッセージ ID: badbreak

## スイッチ選択式は整数型でなければなりません

スイッチ選択式で使用できるのは整数型だけです。 このエラーメッセージを生成するコードの例を次に示します。

    void foo()
    {
    	float i = 9;
    	switch(i) {	// エラー: i が整数型ではない
    		case 1:
    		case 9:
    			break;
    	};
    return;
    }

メッセージ ID: badcasetype

## 〜から〜にキャストできません

試みられたキャストは不当です。コンストラクタまたは変換関数を使用して変換してください。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
            int i;
    };

    union B {
            int j;
            double k;
    };

    class C {
    public:
            int c;
            operator A();
    	operator int();
    };

    void foo() {
            B b;
            A a;
            C c;
            b = (B)a; // エラー: A から B にキャストできない
            c = (C)a; // エラー: A から C にキャストできない
    	a = A(c); // ok
    	int i = c; // ok
    }

メッセージ ID: badcast

## プリプロセッサ指令に不当な文字があります

プリプロセッサ指令に不当な文字が使用されています。

メッセージ ID: badchar

## 予期しない〜がありました

構文エラーが検出されました。 このエラーメッセージを生成するコードの例を次に示します。

    void foo()
    {
        goto b: // エラー:"b:" ではなく "b;"
     でなければならない
    b:
    	return;
    }

    class B {
        public:
            int j;
            A anA;

        class A {
            public:
                int i;
        };
    };

    int main()
    {
      B aB;
      aB.anA:i = 1;  // エラー::" ではなく "."
    return 0;
    }

メッセージ ID: badcolon

## 〜を記述できる位置は型修飾子の前か後だけです

スコープ演算子が型修飾子の前または後に記述されていませんでした。 このエラーメッセージを生成するコードの例を次に示します。

    class B {
    public:
      static int i;
      static int j;
    };

    ::int i;      //  エラー
    B::j = 9; // ok

メッセージ ID: badcolon2

## 〜は両側にトークンがなければなりません

## 演算子の両側にはトークンがなければなりません。 このエラーメッセージを生成するコードの例を次に示します。

    #define foo(a)	abc ##       // エラー

メッセージ ID: badconcat

## コンストラクタ初期設定子を持てるのはコンストラクタだけです

コンストラクタ初期設定子を持てるのはコンストラクタだけです。 このエラーメッセージを生成するコードの例を次に示します。

    class B {
      int i;
      B(): i(5) {}  // ok
      void foo() : i(6) {} // エラー
    };

メッセージ ID: badconinit

## 〜から〜の変換に const_cast を使用することは許可されません

この const_cast 変換は不当です。これらの型は互換性がありません。 このエラーメッセージを生成するコードの例を次に示します。

    void foo()
    {
      int j = 5;
      const int i = j;
      int x = const_cast<int>(i); // エラー: i が左辺値ではない。const int から int への変換

    int y = const_cast(j); // エラー: int から float への不当な const_cast 変換

      const int z = const_cast<int>(j); // ok: int から int への const_cast 変換
    }

メッセージ ID: badconstcast

## 〜は有効な定数ではありません

構文エラーです。定数が無効です。 このエラーメッセージを生成するコードの例を次に示します。

    int i = 2ooo; // エラー
    int k = 0x9; //ok

メッセージ ID: badconsterr

## 関数〜を〜と宣言することはできません

このエラーはいくつかの場合に起きます (メンバーでない関数がconst または volatile と宣言された、静的なメンバー関数が const または volatile と宣言された､など）。このエラーメッセージを生成するコードの例:

    class A {
      static void foo() volatile {}; // エラー
    };
    void foo() const {}; // エラー

メッセージ ID: badconstfunc

## コンストラクタは戻り型指定を持つことはできません

コンストラクタは、void などの戻り型指定を持つことはできません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    	int A(); // エラー
    };

メッセージ ID: badcontype

## 継続すべきループがありません

`continue` を使用できるのはループの中だけです。ループには、`while`、`for`、`do-while` などがあります。 このエラーメッセージを生成するコードの例を次に示します。

    void foo()
    {
          int i = 5;
          if ( i > 4 ) {
    	   i = 4;
    	   continue; // エラー: continue の位置がループ中でない
          }
    }

メッセージ ID: badcontin

## 変換関数は戻り型指定を持つことはできません

変換関数は戻り型指定を持つことはできません。演算子の型だけで、戻り値がわかります。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    	int j;
    	float f;
    	int operator int() { return j; };		// エラー: 戻り型は指定できない。
    	operator float() { return f; };		// ok
    };

メッセージ ID: badconvtype

## ユーザーの void への変換は暗黙では使用できません

void 型へのユーザー定義の変換は暗黙では使用できません。void 型への変換は不当です。 この警告メッセージを生成するコードの例を次に示します。

    class A {
    public:
    	operator void();		// 警告
    };

メッセージ ID: wbadconvret

## 宣言が不正に打ち切られています

構文エラーの検出: 宣言が不正に打ち切られています。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
       void f() ; { }   // エラー: 宣言が不正に打ち切られている
    };

メッセージ ID: baddeclerr

## 宣言する識別子がなければなりません

宣言の解析時に識別子が予期されました。typedef 宣言中に字句エラーが検出された可能性があります。 このエラーメッセージを生成するコードの例を次に示します。

    typedef *int my_type; // エラー: 不明なアスタリスク

メッセージ ID: baddecl

## 残りの各パラメータは既定値をもたなければなりません

パラメータリスト内でデフォルト値を宣言する場合、最初のデフォルトパラメータ以降の残りのパラメータもすべてデフォルト値を指定する必要があります。 このエラーメッセージを生成するコードの例を次に示します。

    template <class T=long,
    	  class K> // エラー: デフォルト値がない
    class A {};

    void foo( int a,
    		float b,
    		long c = 6,
    		double e; // エラー
    		int f = 2; )
    {}

メッセージ ID: baddefault

## テンプレートパラメータのデフォルトが無効です

テンプレートパラメータのデフォルトは、定義済みの型または宣言済みの型でなければなりません。 このエラーメッセージを生成するコードの例を次に示します。

    template <class T, class K>
    class A;

    template <class T, class K = Eye>
    class A {
      int i;
    };

メッセージ ID: baddefaultpar

## 同じスコープ内で違う種類として 2 つ宣言されたテンプレートパラメータは、指定されたデフォルトの引数にならない可能性があります

同じスコープ内に、デフォルト引数が異なる同じテンプレート宣言を指定することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    template <class T = int>
    class A;

    template <class T = long> // エラー
    class A {
      int i;
    };

メッセージ ID: sametmpldef

## デフォルトの引数は、同じスコープ内にあるテンプレート関数の以降の宣言では追加できません

同じスコープ内でテンプレート関数の以降の宣言にデフォルトの引数を追加することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    template <class T>
    T foo(T);

    template <class T>
    T foo(T = (T)9)  // エラー
          { return T; }

メッセージ ID: badtmplfundef

## デストラクタ名はクラス名と一致していなければなりません

デストラクタはクラスと同じ名前を持つ必要があります。

メッセージ ID: baddestrname

## デストラクタでは戻り型指定はできません

デストラクタには、void などの戻り型は指定できません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
      A();
      int ~A();
    };

メッセージ ID: baddestrtype

## 予期しない else 節 -- 対応する if がありません

`else` の前に `if` 文が必要です。 このエラーメッセージを生成するコードの例を次に示します。

    void foo() {
           int i = 0;
           else	// エラー: 前に if がない
    	      i++;
    }

メッセージ ID: badelseerr

## 列挙子の値がオーバーフローしています

列挙定数の値が整数の最大値を超えています。整数の最大値はマシンによって異なります。 このエラーメッセージを生成するコードの例を次に示します。

    #include <limits.h>

    enum e { e1=ULONG_MAX, e2 }; /* e2 がオーバーフロー */

メッセージ ID: badenumrange

## 式の書式が不正です

式中に 1 つ以上の構文エラーが存在します。 このエラーメッセージを生成するコードの例を次に示します。

    int* foo() { return int[1]; }

メッセージ ID: badexprerr

## 認識できない言語。C か C++ でなければなりません

`extern` で指定する言語は "C" か "`C++`" でなければなりません。 このエラーメッセージを生成するコードの例を次に示します。

    extern "c" int i;  // エラー:"c" ではなく "C" でなければならない

メッセージ ID: badextern

## 〜はすでに別の言語で宣言されています

この関数はすでに別の言語で宣言されています。許可されるのは 1 つの言語バージョンだけです。 このエラーメッセージを生成するコードの例を次に示します。

    void foo();

    extern "C" void foo() {} // エラー: foo() はすでに C++ として宣言されている

メッセージ ID: badextlnk

## 〜はすでに別の言語で宣言されています

変数がすでに別の言語で宣言されています。 このエラーメッセージを生成するコードの例を次に示します。

    extern "C" int i;
    extern "C++" int i;

メッセージ ID: badextlnkw

## 記憶クラス〜はメンバーには許可されません

使用されている記憶クラスはメンバーには許可されません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    	register int j; // エラー: 記憶クラス register はここで許可されない
    	extern int k;   // エラー
    	auto   int l;   // エラー
    };

メッセージ ID: badfieldstore

## インクルードファイル名の書式が不正です

インクルードファイル名の書式が不正です。 このエラーメッセージを生成するコードの例を次に示します。

    #include 'includefile,h'
    #inlcude stdio.h

メッセージ ID: badfilename

## この関数は使用前にプロトタイプが必要です

関数は使用前にプロトタイプが必要です。このメッセージは、コンパイラが C モードでコンパイルするように設定される場合に表示されます。 この警告メッセージを生成するコードの例を次に示します。

    int main () {
        return foo(); // 警告: 関数にはプロトタイプが必要 (C モードのみ)
    }

メッセージ ID: badfunc

## 関数〜にはプロトタイプが必要です

関数は、プログラムで使用する前にプロトタイプまたは関数定義が必要です。 このエラーメッセージを生成するコードの例を次に示します。

    int main()
    {
      goo(); // エラー
    return 0;
    }

    void goo() {};

メッセージ ID: badfunccp

## 関数は静的または外部でなければなりません

関数の記憶領域は static (静的) か extern (外部) でなければなりません。mutable、register、および auto は許可されません。 このエラーメッセージを生成するコードの例を次に示します。

    static f1(); // ok
    extern f2(); // ok

    // 以下はエラー:
    mutable f1(); // クラスの外では "mutable" は許可されない
    register f2();
    auto f3();

メッセージ ID: badfuncstore

## 関数は配列または関数を返すことはできません

構文エラーが検出されました。関数宣言内で不正な戻り型が指定された可能性があります。 このエラーメッセージを生成するコードの例を次に示します。

    int a[] = {1, 2, 3, 6, 4, 5};
    typedef void bar();

    class A {
      bar goo(); // エラー
      int foo()[] { return a; } // エラー
    };

メッセージ ID: badfunctype

## goto が変数の (または例外の) 初期設定を迂回しています

goto によって迂回されているブロック内で変数が宣言されています。 この警告メッセージを生成するコードの例を次に示します。

    int main()
    {
            int a = 2;

            goto next;
            int b = 3; // b の初期設定がスキップされた
    next:
            a++;
    return 0;
    }

メッセージ ID: badgoto

## インクルードファイルを開けませんでした

インクルードファイルにアクセスできないか、あるいは見つかりません。このインクルードファイルは開けませんでした。インクルードファイル名のスペルを確認してください。

メッセージ ID: badinclfile

## 外部変数は局所的な有効範囲では初期化できません

外部変数は、局所的な有効範囲では初期化できません。 このエラーメッセージを生成するコードの例を次に示します。

    extern int out = 2; // ok

    void foo()
    {
      out = 3; // ok
      extern int in = 9; // エラー
      extern int in2;
      in2 = 10; // ok
    };

メッセージ ID: badinit

## クラスは〜で初期化することはできません

クラスが集合体としてのオブジェクトではありません。括弧を使用した初期化を行えるのは、コンストラクタ、非公開メンバー、限定公開メンバー、基底クラス、仮想関数のどれも持たないクラスだけです。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
      int i;
      int j;
    };
    A a = {1, 2}; // エラー: i と j は非公開。

メッセージ ID: badinitcl

## 初期化に〜を使用することはできません

このオブジェクトに括弧を使用した初期化は使用できません。 このエラーメッセージを生成するコードの例を次に示します。

    namespace N {
      int i;
      int j;
    }

    N n = { 1, 2 };

メッセージ ID: badinitbrace

## 初期化するには左辺値が必要です

参照への代入は、左辺値を使用して行う必要があります。 このエラーメッセージを生成するコードの例を次に示します。

    int &i = 3; // エラー
    const int i = 0;
    int &ri = i; // エラー: const int i は左辺値ではない

    int j = 0;
    int &rj = j; // ok

    short sv = 9;
    int &ir = sv; // エラー: int 参照 "ir" に short を代入するためには、
                  // "ir" が実際の整数を参照している必要がある。

以前には旧式事項であったエラーを修正する例を以下に示します。

    void foo() {
    	short sv = 9;
    	int &ir = sv; // エラー: int 参照 "ir" に short を代入するためには、
            	      // "ir" が実際の整数を参照している必要がある。

次のコードはこのエラーを修正します。

    	int *j;
    	*j = (int)sv;
    	int &jr = *j; // ok:jr" は int への参照。
    }

メッセージ ID: badinitlval

## 初期化に〜を使用することはできません

変数の初期化に使用された型が不当です。この代入を行うには、コンストラクタ、変換演算子、または代入演算子の多重定義を使用できます。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
      int j;
    public:
      operator int() {return j; } // A の変換演算子
    };

    void foo() {
      A a;
      int i = a; // ok: A から int への変換が指定されている
      a = new A(); // エラー: A* を使用して A を初期化している
    };

    void bar() {
            int i = 9;
            char *a = &i; // エラー: char* の初期化に int* を使用できない
    }

メッセージ ID: badinittype

## コンストラクタの引数リストで配列メンバーを初期化することはできません

配列メンバーは、コンストラクタの引数リストで初期化することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
      int i[3];
      int j;
      A(): i(1,2,3),
           j(3) {};
    };

メッセージ ID: badarrayinit

## 整数が大きすぎて、表現できません

整数が大きすぎて、このマシンでは表現できません。 このエラーメッセージを生成するコードの例を次に示します。

    int i = 999999999999999999999999999999999;

メッセージ ID: badinteger

## line 指令には符号なしの 10 進数と文字列が必要です

line 指令には符号なしの 10 進数が必要です。 このエラーメッセージを生成するコードの例を次に示します。

    #0x12 // エラー
    #line 0xff "file.cc" // エラー
    #line 12345 "file.cc" // ok

メッセージ ID: badlinedir

## line 指令が指定できるのは 1 から 32767 までです

line 指令が指定できる整数は 1 から 32767 までです。 このエラーメッセージを生成するコードの例を次に示します。

    #line 1234567 "file.cc"

メッセージ ID: badlinenum

## 〜は以前に〜と宣言されています

識別子はすでに別のリンケージで宣言されており、これを変更することは不可能です。 このエラーメッセージを生成するコードの例を次に示します。

    extern char * static_and_extern();
    static char * static_and_extern(); // エラー: 以前に static (静的) ではなく extern (外部) と宣言された

メッセージ ID: badlinkage

## main() には int の戻り値型がなければなりません

規格では、`main()` には `int` の戻り型が必要です。 このエラーメッセージを生成するコードの例を次に示します。

    void main() {}

メッセージ ID: badmain

## main() のアドレスをとることはできません

規格では、`main()` 関数のアドレスをとることは不当です。 このエラーメッセージを生成するコードの例を次に示します。

    int main()
    {
            int *a = main;
            return 0;
    }

メッセージ ID: badmainaddr

## main() の再帰呼び出しはできません

main の再帰呼び出しは許可されていません。 このエラーメッセージを生成するコードの例を次に示します。

    int main()
    {
    	main();
    	return 0;
    }

メッセージ ID: badmaincall

## main() を多重定義することはできません

main() を多重定義することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    int main( int j) // エラー: main() は多重定義できない
    {
    	return 0;
    }

    int main()
    {
    	return 0;
    }

メッセージ ID: badmainol

## 〜はコンストラクタでは初期化できません

基底クラスのメンバーは、派生クラスのコンストラクタ初期設定子によって直接初期化することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    class B {
    	public:
    		int i;
    		int j;
    		B() { i = 0; j = 0; }
    };

    class A: B {
    	int k;
    	A(): i(7), j(5) {
    	// i(7) のエラー: j(5) はコンストラクタでは初期化できない
    		B(); // ok: 基底クラスコンストラクタによる初期化
    		i = 7;
    		j = 9;
    	}
    };

メッセージ ID: badmembinit

## クラスを定義する前にポインタを通してメンバー関数を呼び出すことはできません

クラス本体が定義されるまで、メンバー関数へのポインタを通してメンバー関数を呼び出すことはできません。 このエラーメッセージを生成するコードの例を次に示します。

    class A;

    void (A::* f_ptr) ();

    int main () {
        A *a;
        (a->*f_ptr)();
    }

メッセージ ID: badmfcall

## メンバー関数が記憶クラス〜を持つことはできません

メンバー関数は、記憶クラス `mutable`、`auto`、`register`、および `extern` を持つことはできません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
      mutable void f1();  // エラー
      auto void f2();     // エラー
      extern void f3();   // エラー
      static void f4();   // ok
      register void f5(); // エラー
    };;

メッセージ ID: badmfstore

## 8 進定数に不当な数字が含まれています

8 進定数に使用できるのは数字の 0 〜 7 です。 このエラーメッセージを生成するコードの例を次に示します。

    int i = 08; // エラー: 8 は 8 進数に認められていない数字

メッセージ ID: badoctal

## 多重定義された関数のうち、C を外部宣言できる関数は 1 つだけです

多重定義された関数のうち、`"C"` を外部宣言できる関数は 1 つだけです。このエラーメッセージを生成するコードの例:

    extern "C" int foo (char);
    extern "C" int foo (double); // エラー: extern "C" 関数が別の extern "C" 関数に
                                 // よって多重定義された

メッセージ ID: badollnk

## 引数の数が不当です

多重定義された演算子を宣言している引数の数が多すぎます。演算子が受け付けるパラメータの数は変更できません。 このエラーメッセージを生成するコードの例を次に示します。

    class B {
      int j;
      B operator +(B, B); // エラー:B operator +(B)" でなければならない
    };

メッセージ ID: badopcount

## 戻り値型を持つことはできません

new 演算子および delete 演算子の戻り値型が不正です。 このエラーメッセージを生成するコードの例を次に示します。

    #include <stddef.h>
    class A {
      A* operator new[] (size_t);  // エラー: 戻り値型は void* でなければならない
      A operator delete[] (void*);  // エラー: 戻り値型は void でなければならない
    };

メッセージ ID: badoprtype

## パラメータ型が不当です

コンストラクタまたは演算子内で使用されているパラメータは許可されていません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    	 void operator delete[] (long* );  // エラー: long* ではなく void* でなければならない

    	A(A); // エラー: コピーコンストラクタ内のパラメータはクラス型への参照でなければならない
    };

メッセージ ID: badoptypes

## パラメータ要素に誤りがあります

(K&R) 引数が宣言されていますが、パラメータリストで定義されていません。このエラーメッセージを生成するコードの例:

    void foo (a,b)
        int a;
        char b;
        long d;     // エラー: d はパラメータリストで定義されていない
    {}

メッセージ ID: badparamerr

## 引数は整数型でなければなりません

多重定義された後置 2 項演算子は、int 型の引数をとる必要があります。 このエラーメッセージを生成するコードの例を次に示します。

    class B {
      B operator++(); // 前置 ++b
      B operator++(float); // 後置 b++、
                           // エラー: B operator++(int) でなければならない
    };

メッセージ ID: badpostfix1

## 2 番目の引数は int 型でなければなりません

後置演算子の 2 つ目の引数は int 型の値でなければなりません。 このエラーメッセージを生成するコードの例を次に示します。

    template<class T>
    T operator ++(T &t, float); // エラー: float を int に変更してください

メッセージ ID: badpostfix2

## 認識できないプリプロセッサ指令

このプリプロセッサ指令は認識できません。スペルを調べてください。 このエラーメッセージを生成するコードの例を次に示します。

    #bad_directive

メッセージ ID: badppdir

## 定数式の書式に誤りがあります

プリプロセッサ指令内に定数式があるべきですが、見つかりませんでした。 このエラーメッセージを生成するコードの例を次に示します。

    #if 0xkl0   // エラー: 定数式の書式に誤りがある

    #fi

メッセージ ID: badppexpr

## 単純な型はデストラクタを持つことはできません

`int`、`float`、`char` などの単純な型はデストラクタを持つことはできません。 このエラーメッセージを生成するコードの例を次に示します。

    int main() {
      int *i = new int(0);
      i->int::~int(); // エラー: 代わりに "delete i" を使用してください
    }

メッセージ ID: badpseudodestr

## 非仮想関数が純粋仮想と宣言されています

純粋仮想と宣言できるのは仮想関数だけです。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    	A() = 0; // エラー: A::A() は仮想ではないのに純粋仮想と宣言されている
    	virtual void foo() = 0; // ok
    };

メッセージ ID: badpuref

## 純粋仮想関数の定義構文に誤りがあります

純粋仮想関数は、virtual (仮想) と宣言し、= 0 に設定する必要があります。他の構文はエラーになります。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    	A() = 0; // エラー: A::A() が仮想でない
    	virtual void foo() = 1; // エラー:"1" ではなく "0" でなければならない
    	void foo() = 99; // エラー: A::foo() が仮想でない

    	virtual void foobar() = 0; // ok
    };

メッセージ ID: badpuresyn

## 型が違います

"?:"

    void foo()
    {
      int *x;
      int y;
      int i = (1 == 4 ) ? x : y; // エラー
    }

メッセージ ID: badquesttypes

## 浮動小数点定数が無効です

浮動小数点定数が無効です。大きすぎてオーバーフローしているか、数値の後に有効な文字 (F、f、L、または l) がありません。 このエラーメッセージを生成するコードの例を次に示します。

    float i = 123.34f; // ok
    float j = 987.2g; // エラー

メッセージ ID: badreal

## 変換に reinterpret_cast を使用することは許可されません

`reinterpret_cast` は許可されません。 このエラーメッセージを生成するコードの例を次に示します。

    struct B { int j; };
    struct A: B { int i; };

    void foo() {
    	B *b = new A;
    	A *a1 = new A;
    	int *i = (int*)a1;

    	int j = reinterpret_cast<int> (*a1); // エラー: a1 を int に変換できない
    	a1 = (A*)i;  // ok: ポインタ型
    	b = (B*)a1; // ok
    	a1 = (A*)b; // ok
    }

メッセージ ID: badreintcast

## 関数は〜を返すため〜は返せません

この関数は、関数宣言で指定されているものとは違う型を返します。 このエラーメッセージを生成するコードの例を次に示します。

    class A{
    	A foo() {
    		char a = 'c';
    		return a;
    	}
    };

メッセージ ID: badreturn

## 予期しない〜があります。括弧の対を確認してください

予期しない ")" が検出されました。 このメッセージを生成するコードの例を次に示します。

    int main(){
    int i;
    ); // エラー: 対がない右括弧

メッセージ ID: badrparerr

## 変換に static_cast を使用することは許可されません

静的キャストが認められるのは、ある型から別の型への暗黙の変換が存在する場合だけです。 このエラーメッセージを生成するコードの例を次に示します。

    struct A {
      operator int();
    } a;

    struct B {} b;

    void foo()
    {
      int i = 3;
      double d = 3.14159;

      i = d; // ok
      i = static_cast<int> (d); // ok

      static_cast<A> (i); // エラー
      static_cast<B> (a); // エラー

      int(a); // ok: 型 A から int への変換が指定されている
      static_cast<int> (a); // ok
    };

メッセージ ID: badstaticcast

## 関数〜を静的にはできません

このメンバー関数は静的と宣言できません。 このエラーメッセージを生成するコードの例を次に示します。

    #include <iostream.h>
    class A {
      static A foo();  // ok

      // 以下はエラー:
      static A();
      static A( int i, int j );
      static ~A();
      static A operator+(A a);
      static istream& operator>>(A& a);
    };

メッセージ ID: badstatmf

## 関数が同時に仮想でかつ静的にはなり得ません

関数は同時に仮想でかつ静的にはなり得ません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
      static virtual void foo();
    };

    class C {
      virtual void foo();
    };

    class D: C {
      static void foo(); // エラー
    };

メッセージ ID: badstatvirtf

## 未定義のエスケープシーケンス文字があります

文字列内で使用されているエスケープシーケンス文字は定義されていません。 このエラーメッセージを生成するコードの例を次に示します。

    void foo()
    {
      char *a = "Hello World!\i"; // エラー:"\i" は未定義
    }

メッセージ ID: badstring

## 値が大きすぎて 1 文字に納まりません

文字列リテラルの値が大きすぎて、char 型に納まりません。 このエラーメッセージを生成するコードの例を次に示します。

    char c = '\xabc';
    int i = '\xabcdefg';

メッセージ ID: badstringcon

## テンプレートパラメータの値が不当です

配列要素のアドレスおよび静的ではないクラスメンバーの名前またはアドレスは、テンプレート引数として不当です。テンプレート引数は、整数定数、または外部変数へのポインタまたは参照でなければなりません。 このエラーメッセージを生成するコードの例を次に示します。

    template<int* p> class X { };

    int a[10];
    struct S { int m; static int s; } s;

    X<&a[2]> x3;                    //  エラー: 配列要素のアドレス
    X<&s.m> x4;                     //  エラー: 非静的メンバーのアドレス

メッセージ ID: badtemparg

## テンプレートを参照するパラメータの引数は、外部で名前を付けられたオブジェクトでなければなりません

テンプレートを参照するパラメータの引数は、外部で名前を付けられたオブジェクトでなければなりません。一時変数や無名の左辺値は不当です。 このエラーメッセージを生成するコードの例を次に示します。

    template <int &i>
    struct A {
      int &j;
      A();
    };

    int j = 9;

    void foo( int i ) {
      A<i> a1; // エラー: i は一時変数

      extern int x[3];
      A< x[1] > a2; // エラー: テンプレートパラメータに対し配列要素のアドレスは不当

     extern int x;
      A a3;  // ok
      A a4; // ok
    };

メッセージ ID: badtmplrefarg

## テンプレートパラメータが〜型を持つことはできません

テンプレートパラメータの型は整数型でなければなりません。

メッセージ ID: badtemppar

## 演算子〜の演算対象は左辺値でなければなりません

単項演算子の演算対象は左辺値でなければなりません。 このエラーメッセージを生成するコードの例を次に示します。

    void foo() {
    const int x = 7;
    x++; // エラー

    int j = --9; // エラー
    }

メッセージ ID: badunaryop

## this を使用できるのは非静的のメンバー関数内だけです

`this` を使用できるのは静的でないメンバー関数だけです。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
      int j;
    public:
    	static void foo()  { this.j = 20*j; } // エラー
    	void foobar() {this.j = 21*j; }; // ok
    };

メッセージ ID: badthis

## 型指定子〜はここでは正しくありません

指定された型指定子はこの位置には許可されません。

メッセージ ID: badtypeerr

## 〜が〜を返すのに対し、仮想関数〜は〜を返します

派生クラスに、基底クラス内の関数で指定されたものとは異なる戻り型の仮想関数があります。 このエラーメッセージを生成するコードの例を次に示します。

    class Base {
         virtual void foo();
    };

    class A: Base {
          int foo(); // エラー: void を返す必要がある
    };

メッセージ ID: badvirttype

## ビットフィールドには〜ビットあります

ビットフィールドに指定されているビットが多すぎます。ビットフィールドの型が小さすぎて指定されたビット数が納まらない可能性があります。 このエラーメッセージを生成するコードの例を次に示します。

    struct tag {
        char a: 32;     // 警告: char は 32 ビットを納めるには小さすぎる
    } t;

メッセージ ID: bfbigger

## ビットフィールドが〜ビットより長くない可能性があります

宣言されているビットフィールドが大きすぎます。ビットフィールドのサイズはマシンによって異なります。 このエラーメッセージを生成するコードの例を次に示します。

    static union {
        int a:33; // エラー: ビットフィールドが (このマシンでは) 32 ビットより長くない可能性がある
    };

メッセージ ID: bftoobig

## ビットフィールドには少なくとも 1 ビットがなければなりません

ビットフィールドは、1 ビットよりも小さいサイズには設定できません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    	int a:0; // エラー: ビットフィールドには少なくても 1 ビットが必要
    };

メッセージ ID: bftoosmall

## オブジェクトに付随した形式のメンバー関数のアドレスを取り出しています

関数ポインタに対してメンバー関数ポインタの代入が試みられた可能性があります。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
        public:
            A () { }

            int goo ();
    };

    int main () {
        A a;
        int (*foo) ();
        // 代わりに次の宣言を使用する必要がある:
        // int (A::* foo) ();

        foo = a.goo;
    }

メッセージ ID: boundfuncaddr

## コンストラクタのアドレスを取り出すことはできません

コンストラクタのアドレスを取り出すことは不当です。 このエラーメッセージを生成するコードの例を次に示します。

    struct A {
      A();
    };

    void foo()
    {
    	const int &i = A::A; // エラー: コンストラクタのアドレスは取り出せない
    }

メッセージ ID: cantaddrcon

## デストラクタのアドレスを取り出すことはできません

デストラクタのアドレスを取り出すことは不当です。 このエラーメッセージを生成するコードの例を次に示します。

    struct A {
      ~A();
    };

    void foo()
    {
    	const int & i = A::~A; // エラー: デストラクタのアドレスは取り出せない
    }

メッセージ ID: cantaddrdest

## 左の演算対象に代入することはできません

const と宣言されていて変更できない左の演算対象の値に代入し直そうとしています。 このエラーメッセージを生成するコードの例:

    const int i = 7;
    int j = 9;

    void foo () {
        i = j; // エラー: 左の演算対象に代入することはできない
    }

メッセージ ID: cantassign

## 演算対象〜に代入することはできません

この演算対象は変更できません。定数値、配列名、および関数は代入できません。 このエラーメッセージを生成するコードの例:

    int i = 7;
    int *const pi = &i;

    int j[5];
    j = 9;

    void foo() {}

    void goo() {
        foo = 5; // エラー: 演算対象 "*foo" には代入できない。
        pi = &i; // エラー: 演算対象 "pi" には代入できない。
    }

メッセージ ID: cantassignop2

## 異なる文字型の文字列を連結することはできません

ワイド文字の文字列と通常文字の文字列は連結できません。 このエラーメッセージを生成するコードの例を次に示します。

    char str [] = "abcdefhg" L"hijklmnop";

メッセージ ID: cantcatstring

## 前に起きたエラーのため、処理を継続することができません

このエラーは、あまりに多くのエラーが検出されてプログラムのデバッグを継続できない場合にコンパイラによって発行されます。

メッセージ ID: cantgoon

## 多重定義可能な演算子が必要です

指定された多重定義可能な演算子が見つかりませんでした。このエラーは、演算子の型がまだ定義されてない場合にも生成されます。 このエラーメッセージを生成するコードの例を次に示します。

    #include <stddef.h>

    class A {
    	void* operator anew[] (size_t); // エラー: 演算子 "anew" が存在しない
    	void operator delete[] (void*);
    };

未定義の型に対して宣言された演算子の例:

    class B {
      operator C(); // エラー: 型 C はまだ定義されていない
    };

    class C {};

メッセージ ID: cantoverop

## 多重定義された関数のアドレスを取り出そうとしています

多重定義された関数は、定義ごとに異なるアドレスを持ちます。取り出すアドレスがあいまいでエラーとなっています。 このエラーメッセージを生成するコードの例を次に示します。

    int foo() {return 1; }
    int foo(int i) { return 0; }

    int main()
    {
      const int & i = foo; // エラー
      const int & j = foo; // エラー
    return 0;
    }

メッセージ ID: cantuseover

## constness へキャストできません

constness へのキャストが試みられました。 このエラーメッセージを生成するコードの例を次に示します。

    class B { virtual void foo(); };

    class A: public B {};

    const B * pb = new A;
    A *pa1 = dynamic_cast<A*>(pb);  // エラー: dynamic_cast は const pb を const ではないポインタにキャストする。

    int j = 4;
    const int *c = &j;
    int *i = reinterpret_cast<int*>(c); // エラー

メッセージ ID: castawayconst

## 型は未完結であり、〜からのキャストが未定義の可能性があります

このエラーは現在実装されていません。 不完全で void ではない構造体からのキャストの場合、このエラーが発行されます。

メッセージ ID: castfrominc

## 型は未完結であり、〜へのキャストが未定義の可能性があります

このエラーは現在実装されていません。 不完全で void ではない構造体へのキャストの場合、このエラーが発行されます。

メッセージ ID: casttoinc

## 例外ハンドラへデフォルトのパラメータを渡せません

例外ハンドラはデフォルトのパラメータを持つことはできません。 このエラーメッセージを生成するコードの例を次に示します。

    int main ()
    {
       int i = 3;

       try
       {
          if (i < 100)  throw 100;
       }
       catch (int j = 1000)  // エラー
       {
          i += j;
       };
    }

メッセージ ID: catchdef

## 派生クラスのハンドラがその基底クラスのハンドラの後に置かれています

この警告は、派生クラスのハンドラがその基底クラスのハンドラの後に置かれている場合に生成されます。2 つ目の例は例外を捕獲できません。最初の例は、基底クラスのインスタンスと派生クラスのインスタンスの例外を一致させます。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    public:
      int i;
      A() { i = 1; }

    };

    class B: A {
    public:
      int j;
      B() { j = 2; }
    };

    int main ()
    {
       A a;
       B b;

       try
       {
          if ( b.j != 3)
    	  throw a;
          if ( a.i != 2)
    	  throw b;
       }
       catch (A anA)  // 例外 A と B を捕獲する
       {
         a.i = anA.i + 1;
       }
       catch (B anB) { // 警告: ハンドラに到達できない
         b.j = anB.j + 1;
       };

    }

メッセージ ID: catchderive

## 例外ハンドラが二重定義されています

`try` の後に複数の例外ハンドラが存在します。 この警告メッセージを生成するコードの例を次に示します。

    int main ()
    {
       int i = 3, j = 4;

      try
       {
          if ( i == 3 || j == 4 )
    	  throw 5;
       }
       catch (int x)
       {
          i = x + 1;
       }
       catch (double z) // ok
       {
          i = j = i + j;
       }
       catch (int y )  // エラー: 重複した例外ハンドラ、同じ型
       {
          j = 2;
       };

    }

メッセージ ID: catchdup

## 1 つのハンドラに複数の例外が指定されています

ハンドラに指定できるのは 1 つの例外だけです。 このエラーメッセージを生成するコードの例を次に示します。

    int main() {
      int i = 3;
      double j = 4;

      try
      {
         if ( i != 3 )
            throw 3;
         if ( j != (double)4 )
            throw (double)4;
      }
      catch ( int x, double y ) // エラー: 1 つのハンドラに複数の例外が指定されている
      {
         i = 3;
         j = 4;
      }
    return 0;
    }

メッセージ ID: catchmularg

## ハンドラに例外が指定されていません

ハンドラに例外を 1 つ指定する必要があります。 このエラーメッセージを生成するコードの例を次に示します。

    int main() {
      int i = 3;

      try
      {
         if ( i != 3 )
            throw 3;
      }
      catch (  ) // エラー: ハンドラに例外が指定されていない
      {
         i = 3;
      }
    return 0;
    }

メッセージ ID: catchnoarg

## try ブロックには少なくとも 1 つのハンドラがなければなりません

`try` には、少なくても 1 つの例外ハンドラがなければなりません。 このエラーメッセージを生成するコードの例を次に示します。

    int main ()
    {
       int a = 107;

       try
       {
          if (a > 2000) throw 2000;
          if (a < 100)  throw 100;
          throw a / 3;
       }
       // エラー: 捕獲なし
    }

メッセージ ID: catchnosym

## 前もって指定されたデフォルトの引数値を変更することはできません

いったん指定されたデフォルトのパラメータ値は再定義できません。 このエラーメッセージを生成するコードの例を次に示します。

    void foo( int i, int j = 7 ); // j はデフォルト値 7 を持つ

    int main()
    {
    return 0;
    }

    void foo( int i, int j = 9 ) {}
    // エラー: j はすでにデフォルト値 7 を持つと定義されている

メッセージ ID: changedef

## 文字定数〜中の文字が多すぎます

文字定数の長さが、`char` の最大の記憶スペースを超えています。使用されるのは、通常の文字定数では最初の 4 文字、ワイド文字定数では最初の 1 文字だけです。1 文字を超える文字定数は移植できません。 この警告メッセージを生成するコードの例を次に示します。

    char c = '9999'; // ok
    char ch = '12345'; // エラー

メッセージ ID: chartoolong

## クラスまたは構造体を共用体に変更することはできません

すでにクラス型または構造体型として定義されているオブジェクトを共用体として再定義することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
      int i;
    };

    union A { // エラー
      int i;
      long j;
    };

メッセージ ID: cltounion

## 共用体をクラスまたは構造体に変更することはできません

共用体型として定義されているオブジェクトをクラス型または構造体型として再定義することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    union A {
      int i;
      long j;
    };

    class A {
      int i;
    };

メッセージ ID: clfromunion

## ここでは宣言は許可されません

(C モード) C では、宣言を文と組み合わせることはできません。 このエラーメッセージを生成するコードの例:

    void foo () {
        int a = 0;

        a++;

        int c;      // エラー: ここで宣言は許可されない
    }

メッセージ ID: declplaceerr

## クラスのベクトルはデフォルトの初期設定子を使用しなければなりません

クラスのベクトルはデフォルトのコンストラクタだけを使用する必要があります。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
         A() {};
    };

    typedef A B[5];

    void foo() { B b(1, 2, 3, 4, 5); }; // エラー

メッセージ ID: defaultonly

## 条件で型を定義できません

条件式内での型定義は不当です。 このエラーメッセージを生成するコードの例を次に示します。

    int main () {
        for (int i = 0; struct t {}; j++)   // エラー: 'struct t' はここで定義できない
            ;
    }

メッセージ ID: defincond

## デストラクタをアクセスできません

クラスのデストラクタが非公開で、または保護されていて、ここからアクセスできません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    private:
            ~A();
    public:
            char *ch;
            A();
    };
    void foo() throw(A) {
        throw A();  // エラー: デストラクタはアクセス不能
    }

    int main () {
        foo();
    }

メッセージ ID: destnotacc

## 〜を返すと宣言されていた〜が〜を返しています

同じ関数が異なる 2 つの型を返すと宣言されました。 このエラーメッセージを生成するコードの例を次に示します。

    void foo();
    int foo(); // エラー: foo() はすでに void を返している。

メッセージ ID: difreturns

## 浮動小数点の除算にオーバーフローがありますが、処理は実行時に持ち越されました

浮動小数点の除算式の評価がオーバーフローするとコンパイラが判断しました。

メッセージ ID: divfovfl

## 0 で除算しようとしています

コンパイラが、整数値のゼロ除算が行われておりオーバーフローすると判断しました。 このエラーメッセージを生成するコードの例を次に示します。

    int i = 1/0;

メッセージ ID: divovfl

## 0 で除算しようとしていますが、処理は実行時に持ち越されました

ゼロ除算が試みられていますが、処理は実行時に持ち越されました。 この警告メッセージを生成するコードの例を次に示します。

    int i = 9;
    int j = i/0;

メッセージ ID: divovflnv

## switch 内で default が重複しています

その `switch` 文に default 文が 2 つ存在します。 このメッセージを生成するコードの例を次に示します。

    f(void){
            long i = 5;
    	switch(i) {
    	case 1:
    	case 2:
    		    break;
    	default:
    	default:    // エラー: デフォルト文が複数存在する
    	}
    }

メッセージ ID: doubdefault

## 2 つの連続した下線があります

下線が連続して 2 つ使用されているために警告が出力されました。名前が、コンパイラによって生成されるコードの内部名と衝突している可能性があります。

メッセージ ID: doubunder

## この基底クラスはアクセスをすでに指定されています

基底クラスのアクセスは 1 度しか指定できません。 このエラーメッセージを生成するコードの例を次に示します。

    class B {};

    class D: public private protected B {}; // エラー
    class G: public public {}; // エラー

メッセージ ID: dupaccess

## 基底クラスが複数回組み込まれています

基底クラスは 1 度しか組み込むことができません。 このエラーメッセージを生成するコードの例を次に示します。

    struct A2 {
            int i;
    };
    struct A {
            int i;
    };

    struct A2 {
            int i;
    };

    struct B: A, A2, A { // エラー: 基底クラス A が 2 度組み込まれた
            B() { A::i = 7; };
    };

メッセージ ID: dupbaseclass

## switch 内で case が重複しています

現在の `switch` 文に、同じ定数値を持つ case 文が 2 つ存在します。 このエラーメッセージを生成するコードの例を次に示します。

    f(void){
            long i = 5;
    	switch(i) {
    	case 4:
    	case 4:
    		    break;
    	}
    }

メッセージ ID: dupcaselabel

## メンバーは〜よりも前に初期化されています

このメンバーは、コンストラクタの初期設定子リストですでに初期化されています。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
      int i;
      A(): i(0),
           i(0) { // エラー: メンバー i の初期化が重複している
      }
    };

メッセージ ID: dupinit

## dynamic_cast の結果はポインタ型でも参照型でもありません

動的キャストの結果はポインタ型か参照型でなければなりません。 このエラーメッセージを生成するコードの例を次に示します。

    class B {
      virtual foo();
    };

    class D: public B {
      int i;
    };

    B *pb = new D;

    D *pd1 = dynamic_cast<D>(pb); // エラー: キャストの結果はポインタにも参照にもならない
    D *pd2 = dynamic_cast<D*>(pb); // ok

メッセージ ID: dynbadtype

## dynamic_cast の演算対象は多様型へのポインタまたは参照でなければなりません

dynamic_cast の演算対象には多様型へのポインタまたは参照が必要です。型に 1 つ以上の仮想関数がありません。 このエラーメッセージを生成するコードの例を次に示します。

    class B {};

    class D: public B {};

    B * pb = new D;
    D *pd = dynamic_cast<D*>(pb);  // エラー: クラス B に仮想関数がない

メッセージ ID: dynnotpolym

## dynamic_cast の演算対象が参照型ではありません

予期された結果は参照型でしたが、演算対象は参照型、ポインタ型、構造体型のどれでもありません。 このエラーメッセージを生成するコードの例を次に示します。

    class B { virtual void foo(); };

    class D: public B {};

    B *pb = new D;
    int &c = int j;

    D *pd1 = dynamic_cast<D&>(pb); // エラー: 演算対象 pb がポインタである
    D *pd2 = dynamic_cast<D&>(c);  // エラー: c が構造体型ではない

メッセージ ID: dynnotref

## dynamic_cast の演算対象がポインタ型ではありません

dynamic_cast の演算対象はポインタ型でなければなりません。 このエラーメッセージを生成するコードの例:

    class B { virtual foo(); };

    class D: public B { int i; };

    B *pb = new D;
    D d;

    D *pd1 = dynamic_cast<D*>(d); // エラー: d はポインタ型でなければならない
    D *pd2 = dynamic_cast<D*>(pb); // ok

メッセージ ID: dynnotptr

## dynamic_cast の結果が、ポインタかクラスへの参照ではありません

動的キャストに指定した結果がクラスへのポインタまたは参照ではありません。 このエラーメッセージを生成するコードの例を次に示します。

    class B { virtual void foo(); };

    class D: public B {
    };

    B *pb = new D;
    D *pd1 = dynamic_cast<int*>(pb); // エラー: dynamic_cast は型 "D*" を指定する必要がある

メッセージ ID: dynnotclass

## dynamic_cast の演算対象が、ポインタかクラスへの参照ではありません

演算対象がクラスの型を指していません。 このエラーメッセージを生成するコードの例を次に示します。

    class B { virtual void foo(); };

    class D: public B {};

    int *c = int j;
    D *pd = dynamic_cast<D*>(c);  // エラー: c は int を指している

メッセージ ID: dynbadopnd

## 〜が多重に宣言されています

同じ名前で複数のオブジェクトが宣言されました。 このエラーメッセージを生成するコードの例を次に示します。

    int i;
    float i; // エラー

    typedef int I
    //. . .
    int I; // エラー

メッセージ ID: multdecl

## 基底クラス〜は〜より前に初期化されました

この基底クラスはすでに初期化されています。 このエラーメッセージを生成するコードの例を次に示します。

    class B {
      int i;
      B() { i = 0; };
    };

    class A: B {
      int i;
      A(): B(),
           B() { // エラー: 基底クラスが再び初期化された
      }
    };

メッセージ ID: dupbaseinit

## 〜はこの宣言にすでに組み込まれています

このエラーメッセージを生成するコードの例:

    int const int i = 9;
    const float const j = 3;

メッセージ ID: duptypeerr

## 〜の本体はすでに定義されています

関数は 1 度しか定義できません。 このエラーメッセージを生成するコードの例を次に示します。

    void foo() { int i; }

    int main()
    {
    	/* コード */
    }

    void foo() { int i; } // エラー: foo() が 2 度定義された

メッセージ ID: dupfuncdef

## この基底クラスは仮想としてすでに宣言されています

基底クラスに対する仮想宣言が多すぎます。基底クラスに必要な仮想宣言は 1 つだけです。 このエラーメッセージを生成するコードの例を次に示します。

    class B {};
    class D: virtual public virtual B {}; // エラー: 仮想宣言が多すぎる

メッセージ ID: dupvirtspec

## catch(...) は最後のハンドラでなければなりません

"catch(...)" は例外ハンドラブロックの最後のハンドラでなければなりません。 このエラーメッセージを生成するコードの例を次に示します。

    int main ()
    {
       int i = 3;

       try
       {
          if (i < 100)  throw 100;
       }
       catch (...){} // エラー: この catch 文が最後の catch 文になるように移動してください
       catch (int j)
       {
          i += j;
       };
    }

メッセージ ID: eliplaceerr

## 文字定数が空です

文字が含まれない文字定数が使用されました。 このメッセージを生成するコードの例を次に示します。

    f(void) {

    char c = '';    // 提案: char c = ' 'ならば OK
    }

メッセージ ID: emptychar

## 宣言が空です (余分なセミコロンがあると考えられます)

コードの名前空間スコープ (大域的なスコープとファイルスコープを含む) 内に空の宣言文があります。余分なセミコロンがあると考えられます。 このメッセージを生成するコードの例を次に示します。

    namespace {
    ;  // エラー
    };

    class A {
    ;
    }

メッセージ ID: emptydecl

## ファイルには少なくとも 1 つの外部宣言がなければなりません

ファイルが空です。このエラーは、ファイルが `C++` ファイルとしてコンパイルされておらず、かつコンパイラが互換モードでない場合に発生します。

メッセージ ID: emptyfile

## コメント中でファイルが終わりました

コメントの最後に到達する前に EOF が検出されました。 このエラーメッセージを生成するコードの例を次に示します。

    /*
    	メッセージテキスト . . .
    <EOF> // エラー

メッセージ ID: eofincomment

## テキストの読み飛ばし中にファイルが終わりました。#if .. #endif の対が正しいか確認してください

テキストの呼び飛ばし中にコンパイラが EOF を検出しました。#if . . . このエラーメッセージを生成するコードの例を次に示します。

    #if false

    // . . . 対応する #endif のない #if
    // <EOF>

メッセージ ID: eofskipping

## この式は複雑すぎます

この式は、このコンパイラで許可されている演算対象および演算子の最大数を超えています。中間の手順として、この式を小さな式に分割することを検討してください。

メッセージ ID: exprtoomuch

## パラメータリストがコンマで終わっています

パラメータリストはコンマで終わってはなりません。 この警告メッセージを生成するコードの例を次に示します。

    void foo( int i, int j) {}

    int main()
    {
    	foo(1,2,); // エラー
    return 0;
    }

メッセージ ID: extracomma

## メンバーを初期化できるのはコンストラクタの中だけです

メンバーを初期化できるのはコンストラクタの中だけです。 このエラーメッセージを生成するコードの例を次に示します。

    struct A {
    	int i = 9; // エラー
    	int j = 4; // エラー
    };

    class B {
    	int k;
    	B() { k = 7; } // ok
    };

メッセージ ID: fieldinit

## 〜が関数〜を隠しています

派生クラス内の関数が基底クラス内の関数を隠しています。 この警告メッセージを生成するコードの例を次に示します。

    class A {
    public:
      int foo(int);
    };

    class B: A {
    public:
       virtual int foo(char *i);
    };

メッセージ ID: hidef

## 〜が〜を隠してます

通常の delete 演算子はスコープには見つかりませんでした。クラスのスコープ内で operator delete が不当に取り消された可能性があります。 このエラーメッセージを生成するコードの例を次に示します。

    #include <new>

    template<class t_arg> class A {
        public:
            void  operator delete(void*, const std::nothrow_t&) throw(); // エラー: delete(void*) が隠されている。                                                                     // パラメータを 1 つ使用して operator delete を
                                                                         // 指定する必要もある
    };

    int main () {
        A<int> * a = new A<int>;
    }

メッセージ ID: hideferr

## 〜が仮想関数を隠しています

派生クラス内の関数が、基底クラス内の対応する関数を隠しています。この状況は、通常、仮想関数が派生クラス内で宣言し直され、そのプロトタイプが基底クラス内で指定されたものと一致しない場合に発生します。 このエラーメッセージを生成するコードの例を次に示します。

    class B {
    public:
      virtual int foo(int); // B::foo() によって隠されている
    };

    class D: B {
    public:
      virtual int foo(char *i); // B::foo() が仮想 A::foo(int) を隠している
    };

メッセージ ID: hidevf

## 〜が仮想基底クラスにある仮想関数を隠しています

警告。ある関数がその仮想基底クラス内の関数を隠しています。 この警告メッセージを生成するコードの例を次に示します。

    class B {
      void i;
    public:
      virtual int foo(int); // B::foo() によって隠されている
    };

    class D: virtual B {
    public:
      virtual int foo(char *i); // 警告: B::foo() が仮想 A::foo(int) を隠している
    };

メッセージ ID: hidevfinvb

## 〜という名前はデフォルトパラメータでは使用できません

現在のコンテキストでは、この名前をデフォルトパラメータとして使用することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    void foo () {
        int a;

        class A {
            public:
                void goo (int b = a) {} // エラー: ここでは a を使用できない
        };
    }

メッセージ ID: identundef

## 〜という名前は〜では使用できません

この名前は指定されたコンテキストでは使用できません。 このエラーメッセージを生成するコードの例を次に示します。

    void foo () {
        int a;

        class A {
            public:
                void goo () {
                    int k = a; // エラー: ここでは a を使用できない
                }
        };
    }

メッセージ ID: identunnestf

## 〜という名前は非静的なメンバー関数以外では使用できません

この名前を使用できるのは静的でないメンバー関数だけです。このメンバー変数は静的ではありません。このタイプの各インスタンスにはそれぞれ独自のコピーがあります。 このエラーメッセージを生成するコードの例を次に示します。

    struct A {
    	int i;
    };

    struct B: A {
    public:
    	int i;
    	static int j;

    	void foo() { B::i = 2; }	// ok
    	static foobar() { i = 2; } // エラー:"foobar()" は静的であるが "i" は静的でない
    };

    void foobar() {
    	A a;

    	A::i = 7; // エラー: A::i は静的でない

    	B::j = 3; // ok
    	a.i = 7; // ok
    }

メッセージ ID: identunstat

## キャストの中で 〜 を定義することは不当です

キャスト式の中で型を定義することは不当です。 このエラーメッセージを生成するコードの例を次に示します。

    int i;
    float j = ( class A{} ) (i);

メッセージ ID: illegalcast

## 〜は〜からはアクセスできません

クラス内の非公開メンバーへ直接のアクセスを試みました。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
            int i; // 非公開データメンバー
    };

    void foo() {
            A a;
            a.i = 9; // エラー: i は foo() からアクセスできない
    }

    class T {
    	T(const T&); // 非公開コピーコンストラクタ
    };

    void foo( T t ) {}      // エラー: T を渡せない、コピーコンストラクタは非公開
    T f2() { T t; return t; } // エラー: T を返せない

メッセージ ID: inaccessible

## 型が完結していません

型が正しく定義されていないか、あるいは記憶スペースが割り当てられていません。 このエラーメッセージを生成するコードの例を次に示します。

    void i;  // エラー: 型 "void" が完結していない
    void *i; // OK: *i はポインタ型の void である

    class A;
    A a; // エラー

    class B {
      friend void A::f(); // エラー: f は不完全な型のメンバーである
    };

    int xp[];   // エラー: 型 "int[]" が完結していない。
    struct x y; // エラー: 型 "x" が完結していない。
    int main()
    {
        xp [1] = 1;
        return 0;
    }

メッセージ ID: incomplete

## delete 中で使用されている型が完結していません

delete 中で使用されている型が定義されていません。 このエラーメッセージを生成するコードの例を次に示します。

    class A;

    int main () {
        A * a_ptr = 0;
        delete[] a_ptr; // 警告: delete で使用されている型 A は完結していない
    }

メッセージ ID: incompletew

## 〜型の〜は以前に〜と宣言されています

異なる型の変数に、外部リンケージによる変数と同じ名前が指定されました。 このエラーメッセージを生成するコードの例を次に示します。

    extern int i;
    float i; // エラー

メッセージ ID: incomtype

## 〜は以前に〜と宣言されています

(K&R): 関数の多重定義は、K&R モードでは許可されません。 このエラーメッセージを生成するコードの例を次に示します。

    int foo (char);
    int foo (float); // エラー: 多重定義は K&R では許可されない

メッセージ ID: incomtypef

## 共用体メンバーは初期化または廃棄を要求することはできません

共用体は、初期化または廃棄を要求するメンバーを持つことはできません。このエラーメッセージを生成するコードの例:

    class A {
        public:
            A();
    };

    union {
        A   a;  // エラー: 共用体メンバーは初期化または廃棄を要求できない
    } un;

メッセージ ID: initnotall

## 〜はすでに呼び出されており、inline と定義することはできません

この関数はすでに呼び出されており、その宣言には inline キーワードが含まれません。このため、この関数は inline と定義することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
        public:
            void foo ();
    };

    int main () {
        A a;
        a.foo();
    }

    inline
    void A::foo () {}

メッセージ ID: inlafteruse

## 〜は大きすぎるため、インライン展開されません

この関数は大きすぎるため、コンパイラはインラインを生成できません。

メッセージ ID: inllargeuse

## 〜はインラインを生成するには大きすぎます。直接記述してみてください

この関数は大きすぎてコンパイラが自動生成できません。この関数は手動でインライン展開できます。

メッセージ ID: inllargeint

## このラベルは定義されていません

ラベルが使用されましたが、このラベルは定義されていません。 このエラーメッセージを生成するコードの例を次に示します。

    int main()
    {
    	//. . .
            goto label1; // エラー:"label1" は定義されていない
    	//. . .

    return 0;
    }

メッセージ ID: labelundef

## 局所クラスが静的メンバーを持つことはできません

静的メンバーは局所クラス内では宣言できません。 このエラーメッセージを生成するコードの例を次に示します。

    void foo()
    {
            class A {
                    static int i;
            };

    }

メッセージ ID: lcstatic

## 局所クラス中のメンバー関数はそのクラス中で定義されなければなりません

局所クラスの仮想メンバー関数の本体を定義する必要があります。 このエラーメッセージを生成するコードの例を次に示します。

    int main () {
        class inner_class {
            public:
                virtual int foo ();     // エラー
                virtual int goo () {}   // ok
        };
    }

メッセージ ID: lcfnodef

## 〜を使用できるのはブロックの中か関数の引数としてだけです

記憶クラス `auto` および `register` を使用できるのは、ブロックの中か関数の引数としてだけです。 このエラーメッセージを生成するコードの例を次に示します。

    register int a = 3;		// エラー
    auto float b = 3.14159;	// エラー

    void foo( auto int i,		// ok
    		register j )	// ok
    {
    	register int x = 3;	// ok
    	auto int y = 4;		// ok
    }

メッセージ ID: locstorespec

## リンケージ指定はファイルレベルでしか許可されません

リンケージ指定がファイルレベルで指定されませんでした。 このエラーメッセージを生成するコードの例を次に示します。

    extern "C" int k; //ok

    void foo() {
      extern "C" int i; // エラー
      extern "C" int j; // エラー
    };

メッセージ ID: loclinkage

## 文字列または文字の定数に行区切り文字を含めることはできません

文字列または文字の定数に行区切り文字を含めることはできません。 このエラーメッセージを生成するコードの例を次に示します。

    char c = '
    '; // エラー: 行区切り文字が含まれている

メッセージ ID: longstring

## #undef を使用せずに〜を再定義しようとしています

`#undef` を使用せずにマクロを異なる値に再定義することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    #define count 1
    #define count 2 // エラー:  #undef を使用せずに count を再定義しようとしている

メッセージ ID: macroredef

## このマクロのパラメータが多すぎます

このマクロには、このコンパイラで許可されている最大数を超えるパラメータが指定されています。

メッセージ ID: manymacroparms

## マクロパラメータが重複しています

同じ名前を持つ 2 つ以上のマクロパラメータが存在します。パラメータ名は固有でなければなりません。 このエラーメッセージを生成するコードの例を次に示します。

    #define foo( X, X )

メッセージ ID: dupmacroparms

## 〜と〜の間の多重定義にあいまいさがあります

多重定義で呼び出された関数があいまいです。 このエラーメッセージを生成するコードの例を次に示します。

    void foo (int i, int j);
    void foo (int i = 3, int j = 7);//  ok:  foo(int, int) の宣言
    void foo ();                    //  ok:  foo の宣言

    int main()
    {
    	foo (1, 2);             //  ok:  f(int, int) の呼び出し
            foo ();                 //  エラー: f(int,int) と f() のどちらを呼び出すか不明
    }

あいまいさはコンストラクタと変換演算子の使用によっても起こることがあります。

    struct A { A(int); };
    struct B {
    	B(int);
    	operator int();
    	operator double();
    } b;

    A foo( A a );
    B foo( B b );

    int main()
    {
      foo(1); // エラー: foo(A) と foo(b) のどちらか不明
    }

    int i = b;
     // ok: 一致する int にB を変換
    float f1 = b; // エラー: int 演算子と double 演算子のどちらを呼び出すか不明
    float f2 = double(b);
     // ok: 変換演算子の指定

メッセージ ID: manymatchover

## クラスメンバー〜をクラスの外で宣言することはできません

このクラスメンバーはクラスの外では宣言できません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
        public:
    	void foo();
    };

    void A::foobar(); // エラー: クラスの外でメンバーが不正に宣言されている

メッセージ ID: membnotall

## 値付きと値なしの〜からの戻りがあります

この関数は値を返すように宣言されていますが、値付きと値なしの戻りがあります。 この警告メッセージを生成するコードの例を次に示します。

    int foo() {
      int i = 9;
      if ( i == 1 ) return; // エラー: foo() は値を返す必要がある
      else if ( i == 2 ) return 8; // 警告: foo() から値付きと値なしの戻りがある
      else if ( i == 3 ) return 1; // 警告
      else if ( i == 9 ) return; // エラー
      else
        return 1; // 警告
    };

メッセージ ID: mixedreturns

## 0 による剰余を計算しようとしています

0 による剰余計算が試みられました。 このエラーメッセージを生成するコードの例を次に示します。

    int i = 1000000 % 0;

メッセージ ID: modovfl

## 0 による剰余を計算しようとしていますが、処理は実行時に持ち越されました

0 による変数剰余の計算が試みられました。この警告の処理は実行時に持ち越されました。 この警告メッセージを生成するコードの例を次に示します。

    void foo()
    {
    	int i = 9;
    	i%0;   // 警告: 0 による剰余の計算
    }

メッセージ ID: modovflnv

## 浮動小数点の乗算にオーバーフローがありますが、処理は実行時に持ち越されました

浮動小数点の乗算式がオーバーフローするとコンパイラが判断しました。処理は実行時に持ち越されました。

メッセージ ID: mulfovfl

## 整数のオーバーフローが検出されました

コンパイラがコンパイル時に乗算結果の計算を試み、結果がオーバーフローすると判断しました。結果の下位 32 ビットが保持され、この診断が発行されます。 このメッセージを生成するコードの例を次に示します。

    int i = 1000000 * 1000000;

メッセージ ID: mulovfl

## この名前には複数の修飾子がありますが、許可されるのは 1 つだけです

複数の修飾子は許可されていません。

メッセージ ID: multqualerror

## このクラスは直接の基底クラスではありません

このクラスは直接の基底クラスではありません。このクラスのメンバーは、基底クラスによって直接使用することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    struct B {
      int j;
      void foo() { /* B::foo() */ };
    };

    struct A: B { // B は A の基底クラス
      int i;
      void foo() { /* A::foo() */ };
    };

    A *pa;
    B *pb;
    A a;
    B b;

    int main() {
      pa = &a;
      pb = &b;

      pa->B::foo(); // ok
      pb->::foo(); // エラー: A::foo() は基底クラスのポインタ型 B によって
                    // アクセスできない
    return 0;
    }

メッセージ ID: mustbebase

## 宣言される演算子はメンバー関数でなければなりません

宣言される演算子はメンバー関数でなければなりません。演算子 "="、"->"、"{"、"()"、および型変換はメンバーとして定義する必要があります。演算子の定義内にスコープ演算子が抜けていないか確認してください。 このエラーメッセージを生成するコードの例:

    class B {
      int i;
      operator =(const B&);
    };
    B::operator =(const B &b){ return (this->i + b.i); }; // ok: メンバーとして定義されている

    // 以下はエラーを生成する:
    B operator ->();
    B operator {();
    B operator ()();
    B operator int();

メッセージ ID: mustbemem

## 関数の配列を持つことはできません

関数は関数の配列を返すことはできません。 このエラーメッセージを生成するコードの例を次に示します。

    void foo[3] (); // エラー

メッセージ ID: noarroffunc

## 参照の配列を持つことはできません

参照の配列は許可されていません。 このエラーメッセージを生成するコードの例:

    int main() {
    	int &j;    // ok
            int &i[3]; // エラー
    }

メッセージ ID: noarrofref

## 初期化すべき基底クラスがありません

このクラスは派生クラスではないため基底クラスを初期化できません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
      int i;
      A(): (10) {};
    };

メッセージ ID: nobaseclass

## 〜が予期される位置に〜があります

この文には "=" がありません。 このエラーメッセージを生成するコードの例を次に示します。

    void foo()
    {
        if ( const int i 2 ) // エラー: i の後に "=" が抜けている
        ;
    }

メッセージ ID: nobecomeserr

## ビットフィールドのアドレスを取り出すことはできません

ビットフィールドのアドレスを取り出すことは不当です。 このエラーメッセージを生成するコードの例を次に示します。

    struct A {
      int i:3;
      int j:4;
      int k:5;

      int foo() { return &i; } // エラー:
    };

メッセージ ID: nobitaddr

## ビットフィールドへの参照を持つことはできません

ビットフィールドへの参照は不当です。 このエラーメッセージを生成するコードの例を次に示します。

    struct A {
      int i:3;
      int j:4;
      int k:5;

      int &foo() { int &ri = i; return ri;}  // エラー
    };

メッセージ ID: nobitref

## 〜は〜のメンバーではありません

メンバーではないオブジェクトまたは関数へのアクセスが試みられました。 このエラーメッセージを生成するコードの例を次に示します。

    void foo() {}
    void foobar() {}

    class A {
    public:
      int i;
      int j;

      friend void foo();
    };

    void A::goo() {}; // エラー: goo は A のメンバーではない

    int main()
    {
      A a;
      a.i = 0;    // ok
      a.foobar(); // エラー: foobar は A のメンバーではない
      a.foo();    // エラー: foo は A のフレンドであるが A のメンバーではない
    }

メッセージ ID: nofieldfnd

## 〜が予期される位置に〜があります

構文エラーが存在します。 このエラーメッセージを生成するコードの例を次に示します。

    void foo()
    {
    	int i = 0;
    	switch (i) {
    		case 3:
    		case 4; // エラー::"

    			break;
    	};
    };

メッセージ ID: nocolonerr

## この〜の後に〜がありません

"?" のあとに ":" が必要です。 このエラーメッセージを生成するコードの例を次に示します。

    int main()
    {
      int i= -7;
      i = ( i < 0 ) ? -i  i; // エラー:""?" のあとに ":" が必要
    }

メッセージ ID: nocolonop

## コンマが予期される位置に〜があります

コード内に構文エラーがあります。 このエラーメッセージを生成するコードの例:

    int foo( int i; int j) // エラー:"";" ではなく "," でなければならない
    {
      return i*j;
    }

    struct A {
      int k;
    } a, aa:
    // エラー:"," の後に宣言が続くか、あるいは ":"

メッセージ ID: nocommaerr

## -noex を付けてコンパイルするときは throw 式は無視されます

コンパイラ引数 `-noex` が使用されたため throw が無視されました。

メッセージ ID: noexthrow

## -noex を付けてコンパイルしたときは try と catch は無視されます

コンパイラ引数 `-noex` が使用されたため、例外機構 try と catch が無視されました。

メッセージ ID: noextry

## 識別子リストが予期される位置に〜があります

識別子リストには、")" でリストが終了する前に EOL (行末) が存在します。マクロは 1 行で定義しなければなりません。"\" が抜けている可能性があります。 このエラーメッセージを生成するコードの例を次に示します。

    #define foo( A,  // "\" が抜けている
    	     B )

メッセージ ID: noidentlist

## 定数メンバーが初期化されていません

`const` メンバーオブジェクトは初期化する必要があります。

メッセージ ID: noconstinit

## 配列の new には初期設定子は許可されません

演算子 new[] を使用して配列を割り当てる場合、初期設定子は指定できません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
        public:
            A (int k=0) {}
    };

    int main () {
        A * ptr = new A[2](3); // エラー: 初期設定子として \'3\' を指定する必要はない
    }

メッセージ ID: noconstrparm

## 宣言が予期される位置に〜がありました

クラス定義は、セミコロンか、宣言とセミコロンで終わる必要があります。 このエラーメッセージを生成するコードの例を次に示します。

    struct A {
    	int i;
    } a, :

メッセージ ID: nodeclerr

## この宣言には記憶クラスも型もありません

この宣言には記憶クラスも型も指定されていません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    	i;	// エラー: 記憶クラスも型も指定されていない
    };

メッセージ ID: nodeclspec

## デフォルトパラメータは許可されません

多重定義された演算子または関数のポインタに対してデフォルトパラメータ値は許可されません。 この警告メッセージを生成するコードの例を次に示します。

    class T {
      int i;
    public:
      T(int j);

    };

    T operator+ (T t, T t2= T(0) ); // エラー: 多重定義された演算子内ではデフォルトパラメータ値を指定できない。
    void (*fptr)(int k = 3); // エラー: 関数へのポインタ内ではデフォルトパラメータ値を指定できない。

メッセージ ID: nodefall

## 演算子 new では〜の定義は許可されません

演算子 new ではどの型も定義できません。 この警告メッセージを生成するコードの例を次に示します。

    int main () {
        void * t = (void *) new (struct t {}); // エラー: 演算子 new での struct 宣言が
                                               // 検出された。
    }

メッセージ ID: nodefinnew

## 引数の型では〜の定義は許可されません

関数の引数では関数の型を定義できません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
      A();
      friend void foo( class B{} b;);
    };

メッセージ ID: nodefinproto

## 戻り値の型では型の定義は許可されません

戻り値の型指定では型の定義は使用できません。 このエラーを生成するコードの例:

    struct t{} foo () {     // エラー: ここでは 'struct t' を定義できない
    }

メッセージ ID: nodefinret

## sizeof 式では型の定義は許可されません

"sizeof" 式では型を定義できません。 このエラーメッセージを生成するコードの例を次に示します。

    int foo () {
        return sizeof (struct t {}); // エラー: sizeof 式内に struct 宣言が見つかった
    }

メッセージ ID: nodefinsizeof

## typeid 式では型の定義は許可されません

"typeid" 式では型を定義できません。 このエラーメッセージを生成するコードの例を次に示します。

    #include <typeinfo>

    int main () {
        typeid (struct t {}); // エラー: typeid 式内に struct 宣言が見つかった
    }

メッセージ ID: nodefintypeid

## delete 中に個数が指定されています

"delete []" 演算子中での個数の使用は廃止されました。この個数を削除してください。 この警告メッセージを生成するコードの例を次に示します。

    void foo()
    {
      int *i = new int[10];
      delete [10] i;  // エラー:delete []" 中で個数が使用されている
    }

メッセージ ID: nodelno

## 〜の前に直接宣言子がありません

構文エラーです。このトークンの前に直接宣言子が不足しています。 このエラーメッセージを生成するコードの例を次に示します。

    int () {}; // エラー: 関数名が不足している

    struct A {
    	static int i;
    	static int j;
    };

    void foo()
    {
    	A::i = 7; //ok
    	A:: ;  // エラー: 変数が不足している

    	int []; // エラー: 配列名が不足している
    }

メッセージ ID: nodirdecl

## RTTI 機能が有効にされていないため、dynamic_cast は static_cast で置き換えられました

RTTI 機能が有効にされていないため、動的キャストは静的キャストで置き換えられました。

メッセージ ID: nodyncast

## 〜は列挙型のタグではありません

キーワード `enum` の後、構文エラーが検出されました。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
            enum A = { x, y, z }
    };

メッセージ ID: noenumerr

## 式が予期されています

式が予期されましたが見つかりませんでした。 このエラーメッセージを生成するコードの例を次に示します。

      int j =;
      int k = {};
      int l[] = {};
      if ( );

メッセージ ID: noexprerr

## 〜は〜のメンバーではありません

クラス、構造体、または共用体に存在しないメンバーの参照が試みられました。 このエラーメッセージを生成するコードの例を次に示します。

    struct {
    // 次のフィールドが定義されなければならない:
    // int a;
    } t;

    int main () {
        return t.a;
    }

メッセージ ID: nofieldident

## friend 宣言はクラスか関数を指定しなければなりません

friend 宣言にクラス、関数とも指定されていません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
      int i;
      friend;
    };

メッセージ ID: nofriendfield

## クラスに対するフレンド指定では明示的な class が必要です

旧式事項です。クラスに対するフレンド指定では明示的な "class" が必要です。 この警告メッセージを生成するコードの例を次に示します。

    class A {
      int i;
      friend B; // 警告:friend class B" でなければならない
    };

    class B {
      int j;
    };

メッセージ ID: nofriendw

## 関数は構造体または共用体の構成要素にはできません

K&R 互換モードでは、関数は構造体メンバーとして宣言することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    struct {
        int foo () { return 0; } // エラー
    } t;

    int main () {
        return t.foo();
    }

メッセージ ID: nofunchere

## テンプレートおよびキャストのパラメータリストには〜が必要です

テンプレートおよびキャストのパラメータリストには、">" に対応する "<" が必要です。 このエラーメッセージを生成するコードの例を次に示します。

    class B { virtual void foo(); };
    class A: public B {};

    int main()
    {
      B * pb = new A;
      A *pa1 = dynamic_cast<A*(pb); // "A*" の直後に ">" が必要
    }

メッセージ ID: nogtrerr

## 識別子が予期される位置に〜があります

識別子が予期されました。 このエラーメッセージを生成するコードの例を次に示します。

    void foo()
    {
    	int float j; // エラー: int の後に識別子が必要
    	int; // エラー
    	goto; // エラー
    }

メッセージ ID: noidenterr

## 識別子が予期される位置に〜があります (警告)

(K&R、Ansi モード): 識別子が予期されました。 このエラーメッセージを生成するコードの例を次に示します。

    void foo()
    {
    	int; // エラー
    }

メッセージ ID: noidentwarn

## 〜は初期化しなければなりません

外部シンボルでない `const` 値は初期化しなければなりません。 このエラーメッセージを生成するコードの例を次に示します。

    const int *pj = new int(0); //ok
    int a = 10;
    const int i;  // エラー
    const int &j; // エラー
    const int &k = a; // ok
    }

メッセージ ID: noiniterr

## 〜は初期化しなければなりません

(K&R): 外部シンボルでない `const` 値は初期化しなければなりません。 このエラーメッセージを生成するコードの例を次に示します。

    int main () {
        static const int a; // 警告: a は初期化しなければならない
    }

メッセージ ID: noinitwarn

## 〜型のオブジェクトは初期化しなければなりません

new() 演算子で作成された const オブジェクトは、初期値、コンストラクタ、または初期設定子を使用して初期化しなければなりません。 このエラーメッセージを生成するコードの例を次に示します。

    const int *ip = new const int; // エラー
    const int *jp = new const int(0); // ok

メッセージ ID: noinitanac

## 関数の本体が定義されていません

インライン関数の本体が定義されていません。 このメッセージを生成するコードの例を次に示します。

    inline void foo(); // エラー: inline foo() に関数本体が定義されていない

    int main()
    {
    	foo();
    	return 0;
    }

メッセージ ID: noinlbody

## 参照メンバーが初期化されていません

参照メンバーは使用前に初期化する必要があります。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
        public:
    	int &i;
    };
    void foo() {
    	A a;
    	a.i = 7;  // エラー:"a.i" はまだ初期化されていない

    	int j;

    	a.i = j;
    	a.i = 7;  // ok
    }

メッセージ ID: noirefmem

## ラベルの後には文 (空の文でも) が必要です

ラベルの後には文 (空の文でも) が必要です。 このメッセージを生成するコードの例を次に示します。

    main() {
      int i = 10;
      switch (i) {
        case 1:
        default:
            i++;
            break;
        case 2:  // エラー: ラベル "case 2" の後に文がない
      }
    }

メッセージ ID: nolabstaterr

## "{" が予期される位置に〜があります

構文にエラーがあります。 このエラーメッセージを生成するコードの例:

    void foo()
    {
    	int i[] { 1, 2, 3, 4, 5 }
    }

    int main()
    int i;	// エラー:{" が必要な位置に "int" がある
    {
            return 0;
    }

    int foo()
    {
    	int m[] = 5; // エラー:"{" が必要な位置に "5" がある
    	int n[] = { 2, 3, 5 }; // ok
    }

    class A {
    	int i;
    public:
    	A(): i(10); // エラー: コンストラクタを定義する必要がある
    	A(): i(10) {}; // ok
    };

メッセージ ID: nolcurlerr

## 局所変数か一時変数への参照を返します

局所変数か一時変数への参照として返されている値は、関数のスコープ外では使用できません。 このエラーメッセージを生成するコードの例を次に示します。

    int &foo(int i)
    {
       return i; // エラー
    }

    int &foobar(int &i)
    {
       return i; // ok
    }

メッセージ ID: nolocalname

## ビットフィールドへの参照を戻すことはできません

ビットフィールドへの参照を戻り値として使用することは許可されていません。 このエラーメッセージを生成するコードの例を次に示します。

    struct A {
      int i:3;
      int j:4;
      int k:5;

      int &foo() { return i; } // エラー: ビットフィールドへの参照を戻すことはできない
    };

メッセージ ID: noretbitref

## 名前空間は局所的なスコープでは宣言できません

`namespace` は、局所的なスコープでは定義できません。 このエラーメッセージを生成するコードの例を次に示します。

    namespace names { //ok
    	int j;
    	int k;
    };

    void foo() {
        namespace ns { // エラー: namespace が局所的なスコープ内に存在する
          int i;
        };
        ns n;
        n::i++;
    }

メッセージ ID: nolocalns

## -nocx オプションを付けたときは long long const は許可されません

(ccfe): -nocx オプションは、long long および long long const の使用を抑制します。 このエラーメッセージを生成するコードの例を次に示します。

    long foo () { return 0ll; } // -nocx オプションが指定される場合はエラー

メッセージ ID: nollconst

## -nocx オプションを付けたときは long long は許可されません

(ccfe): -nocx オプションは、long long および long long const の使用を抑制します。 このエラーメッセージを生成するコードの例を次に示します。

    long long cll = 0;  // -nocx オプションが指定される場合はエラー

メッセージ ID: nolonglong

## long long のビットフィールドは許可されません

`long long` 型のビットフィールドは許可されません。 このエラーメッセージを生成するコードの例を次に示します。

    class a {
    	long long a:7; // エラー: long long のビットフィールドは許可されない
    	int b:4;
    };

メッセージ ID: nollbitfield

## "(" が予期される位置に〜があります

式中に "(" が予期されましたが見つかりませんでした。 このエラーメッセージを生成するコードの例を次に示します。

    int i;

    for i = 0; i < 7; ++i ) {} // エラー:"(" が必要な位置に "i" がある

    if i < 7); // エラー

メッセージ ID: nolparerr

## "<" が予期される位置に〜があります

このエラーは、キャスト式またはテンプレート内に "<" が不足しているために発生します。このエラーメッセージを生成するコードの例を次に示します。

    class B { virtual void foo(); };
    class A: public B {};

    B *b = new A;
    A *a = dynamic_cast A*>(b);

    template class T>
    class D{};

メッセージ ID: nolsserr

## 基底クラスを初期化するための〜が見つかりません

この基底には、クラスを初期化するための対応するコンストラクタがありません。 このエラーメッセージを生成するコードの例を次に示します。

    class B {
    public:
    	int i;
    	 //B();
    	B(int x) { i = x; }
    };

    class A: B {
    	A() { // エラー: 基底クラスのデフォルトコンストラクタ B::B() が見つからない
    	}
    };

メッセージ ID: nomatchbase

## 〜を初期化するための〜が見つかりません

クラス内のオブジェクトは呼び出しに対応するコンストラクタを含んでいません。 このエラーメッセージを生成するコードの例を次に示します。

    class B {
    public:
    	int i;
    	 //B();
    	B(int x); // コンストラクタが指定された。コンパイラはデフォルトコンストラクタを生成しない
    };

    class A {
    	B b_in_A; // 初期化されていない
    	int i;
    	A(int x) { // エラー: メンバー b_in_A を初期化するデフォルトコンストラクタ B::B() が見つからない
    	i = x;
    	B(1);
    	}
    };

メッセージ ID: nomatchmem

## 〜と一致するものがありません

多重定義された関数またはテンプレート (あるいはこの両方) 内の関数呼び出しと一致するものがありません。 このエラーメッセージを生成するコードの例を次に示します。

    struct S { int &r; };
    int main() {
      struct S *x = new S(0); // エラー: コンストラクタ S::S(int) が見つからない
    };

    class A {
    public:
      int i;
      A();
      A(int a, int b);
    };

    void foo(){
      A a(1,2,3); // エラー: コンストラクタに対し 3 つの引数を渡すが不一致
    }

メッセージ ID: nomatchover

## 対応する ")" がありません

すべての "(" には対応する ")" がなければなりません。 このエラーメッセージを生成するコードの例を次に示します。

    int foo(   // エラー: 対応する ")" がない
    {
      int i = 3;
    reutrn 0;
    }

メッセージ ID: nomatchrpar

## new で〜を代入することはできません

参照と関数型は、`new` 演算子で代入することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    int main () {
        new (int&); // エラー: new で参照を代入しようとしている
    }

メッセージ ID: nonewtype

## 基底クラスを初期化するための〜を〜が見つけられません

この基底クラスにはデフォルトコンストラクタが定義されていません。この基底クラスにコンストラクタが定義されている場合、コンパイラはデフォルトコンストラクタを生成しません。

    struct A { A(int); };
    struct C: A {};

    C c;    // エラー
    C c1(); // ok: コンパイラによりデフォルトコンストラクタが生成される

メッセージ ID: nonulconbase

## 〜フィールドを初期化するための〜を〜が見つけられません

構造体型のメンバーにデフォルトコンストラクタがないか、あるいは含まれている型に 1 つ以上のコンストラクタが提供されていたためコンパイラがデフォルトコンストラクタを生成しませんでした。 このエラーメッセージを生成するコードの例を次に示します。

    struct B {
      int i;
      B(int x);
    };

    struct A {
    	B b_in_A; // A にデフォルトコンストラクタがない
    };

    A a; // ここでエラーが発生

メッセージ ID: nonulcon

## ベクトルを初期化するための〜が見つかりません

デフォルトコンストラクタが生成または定義されませんでした。ベクトルは初期化できませんでした。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    public:
      int i;
      //A();
      A(int);
    };

    A *a = new A[8]; // エラー

メッセージ ID: nonulvec

## const オブジェクトに対して const でない関数が呼び出されています

const オブジェクトが、const と宣言されていないメンバー関数を呼び出しました。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    public:
      A();
      int foo(int i)  {return i;}
    };

    void bar() {
      const int i = 7;
      A const a;
      a.foo(i);
    }

メッセージ ID: nonconmf

## const でないメンバー関数へのポインタが const オブジェクトとともに使用されました

const オブジェクトが、const と宣言されていないメンバー関数を呼び出しました。

メッセージ ID: nonconmfp

## 参照が返す値は左辺値でなければなりません

この関数は参照値を返しますが、左辺でない値が返されました。 このエラーメッセージを生成するコードの例を次に示します。

    int &foo()
    {
    	return 0;
    }

メッセージ ID: nonvarref

## 左辺値でないものを〜にキャストしています

指定された型に左辺値以外をキャストすることはできません。

    int main () {
        const_cast<int&>(0);    // エラー: int& に左辺値以外はキャストできない
    }

メッセージ ID: nonlvalcast

## この関数は値を返すことはできません

宣言されている関数戻り値の指定が void であるため、この関数は値を返すことはできません。 このエラーメッセージを生成するコードの例を次に示します。

    void foo()
    {
    	int i = 3;
    	return i;   // エラー: この関数の戻り型は int ではなく void
    }

メッセージ ID: nonvoidret

## volatile オブジェクトに対して非 volatile の関数〜が呼び出されています

volatile と宣言されているオブジェクトが呼び出せるのは volatile 関数だけです。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    public:
      void foo();
    };

    int main()
    {
      A volatile a;
      a.foo(); // エラー: A::foo() は volatile 関数でない
    }

メッセージ ID: nonvolmf

## volatile でないメンバー関数へのポインタが volatile オブジェクトとともに使用されました

メンバー関数を volatile ポインタから呼び出すには、そのメンバー関数を volatile と宣言する必要があります。 このエラーメッセージを生成するコードの例を次に示します。

    class B {
    public:
      void bar();
    };

    void (B::* b_ptr)();

    int main()
    {
      B volatile *b;
      (b->*b_ptr)(); // エラー: B::bar() は volatile と宣言されていない
    }

メッセージ ID: nonvolmfp

## 〜を呼び出すときはピリオドか矢印を使用してください

メンバー関数をクラスのインスタンスによって呼び出すときは、"." このエラーメッセージを生成するコードの例を次に示します。

    class A
    {
    public:
    	void foo(){ /* コード */ }
    };

    int main()
    {
    	A::foo();
    }

メッセージ ID: noobjcall

## 演算対象が予期される位置に〜があります

演算対象が予期されましたが見つかりませんでした。 このエラーメッセージを生成するコードの例を次に示します。

    void foo()
    {
      int i = 2;
      int j[5];
      i = j[]; // エラー: 添字が不足している
      i = [i]; // エラー: j[i] でなければならない
      double d = ()i; // エラー:"()i" でなく "(double)i" でなければならない
    }

メッセージ ID: nooprnderr

## 整数型からポインタ型を減算することはできません

ポインタ型を整数型から減算することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    void foo()
    {
      int i = 2;
      int *j = &i;

      i = i - j;
    }

メッセージ ID: noptrsub

## ポインタ型が必要な位置に〜があります

このメンバーにアクセスするにはオブジェクトのポインタ型が必要です。 このエラーメッセージを生成するコードの例:

    class A {
       public:
    	int i;
    };

    void foo() {
    	A a;
    	a->i = 8; // エラー:"a" はポインタ型ではない
    };

    void bar() {
    	int j;
    	j[0] = 7; // エラー:"j" はポインタ型ではない
    }

メッセージ ID: noptrvar

## "]" が予期される位置に〜があります

配列の添字に構文エラーがあります。 このメッセージを生成するコードの例を次に示します。

    int i[7];

    i[6} = 10; // エラー:"]" が必要

メッセージ ID: norbrackerr

## "}" が予期される位置に〜があります

"}" が予期されましたが見つかりませんでした。 このエラーメッセージを生成するコードの例を次に示します。

    int a [2] = { 1, 2 ; // エラー:}" を使用して初期設定子リストを
                         // 完結する必要がある

メッセージ ID: norcurlerr

## "}" が予期される位置に EOF があります

対応する "}" が見つかる前に EOF が検出されました。 このエラーメッセージを生成するコードの例を次に示します。

    void foo()
    {
    	/* コード */

    <EOF> // エラー:}" が予期されたが EOF が検出された

メッセージ ID: norcurleof

## typeid と dynamic_cast は RTTI 機能なしでコンパイルする場合は無視されます

flag -feature=no%rtti を設定した場合、typeid と動的キャストは無効になります。

メッセージ ID: nortti

## 参照への参照または参照へのポインタを定義することはできません

参照への参照または参照へのポインタは不当です。 このエラーメッセージを生成するコードの例を次に示します。

    const int &const &i = 12345678; // エラー

    int i;
    int &ri = i;
    int &(*pri) = &ri; // エラー

メッセージ ID: noptrtoref

## 〜への参照を宣言することはできません

void 型への参照が宣言されました。 このエラーメッセージを生成するコードの例を次に示します。

    void &foo(); // エラー: void 型への参照の戻り値を宣言している

メッセージ ID: noreftotype

## メンバー型への参照を宣言できません

非公開または限定公開のクラスメンバーデータに対するアクセスを有効にするメンバー型への参照を宣言することは不当です。

メッセージ ID: noreftomem

## レジスタのアドレスを取り出すことはできません

レジスタにはアドレスがありません。このエラーは、プログラムが `C++` プログラムとしてコンパイルされておらず、レジスタのアドレスの取り出しが試みられた場合に発生します。 このエラーメッセージを生成するコードの例を次に示します。

    register int i = 3;
    int *pi = & i;

メッセージ ID: noregaddr

## ")" が予期される位置に〜があります

構文エラーがありました。式内に ")" トークンが必要です。 このエラーメッセージを生成するコードの例:

    void foo()
    {
      int i = 3;
      switch (i	// エラー:")" が不足している
      {
    	 case 2:
    		i++;
    		break;
      };
    }

    void foobar( int i; float j ) // エラー:"int i" の後に "," が必要
    {
    	if ( i = 9)  // エラー:"=" ではなく "==" でなければならない
    		i++;

メッセージ ID: norparerr

## 文を終わらせるときはセミコロンを使用してください

文は ";" で終わらせる必要があります。 このメッセージを生成するコードの例を次に示します。

    int main()
    {
    	int i;
    	int j = 1;
    	i = j + 3  // エラー

    return 0;
    }

メッセージ ID: nosemierr

## 宣言を終わらせるときはセミコロンを使用してください

宣言は ";" で終わらせる必要があります。 このメッセージを生成するコードの例を次に示します。

    volatile int foo
    int goo ()

メッセージ ID: nosemiheaderr

## ここには文 (空の文でも) が必要です

ここには文 (空の文でも) が必要です。 このエラーメッセージを生成するコードの例を次に示します。

    void foo( int i ) {
    	if ( i < 10 )
    		++i;
    	else
    		// エラー: 文が不足している
    }

メッセージ ID: nostaterr

## ビットフィールドを静的にはできません

静的なビットフィールドは不当です。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
      static int i:4; // エラー
    };

メッセージ ID: nostaticbf

## 変数〜は構造体ではありません

この変数は構造体のインスタンスではありません。 このエラーメッセージを生成するコードの例を次に示します。

    int main ()
    {
    	int j;
    	j.novar = 7;
    return 0;
    }

メッセージ ID: nostructsym

## このドット演算子は構造体ではない型に使用することはできません

このドット演算子は構造体ではない型に使用することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    int main () {
        int().a;    // エラー: int は構造体型ではない
    }

メッセージ ID: nostructype

## このタグはすでに使用されています

このタグはすでに使用されています。 このエラーメッセージを生成するコードの例を次に示します。

    typedef int A;

    class A {};

メッセージ ID: nostructerr

## 〜は静的なデータメンバーではありません

静的メンバーがオブジェクト型のすべてのインスタンスに共有されています。このメンバーは静的ではありません。したがって、オブジェクトのインスタンスを使用してどれを使用するか指定する必要があります。 このエラーメッセージを生成するコードの例を次に示します。

    struct A {
       int i;
       void foo() { A::i = 2; } //ok
    };

    A::i = 7; // エラー: i は静的でない

    void foo()
    {
    	A aa;
    	aa.i = 7; // ok
    }

メッセージ ID: notastatmem

## 〜は〜の基底クラスではありません

`"using"` 指令内に基底クラス名が必要です。 このエラーメッセージを生成するコードの例を次に示します。

    class t {
        public:
            int a;
    };

    class A {
        using t::a; // エラー: t は A の基底クラスではない。t::a を使用できない
    };

メッセージ ID: notbase

## ここには整数定数式が必要です

構文エラー: 整数定数式が必要です。 このエラーメッセージを生成するコードの例を次に示します。

    int a;

    enum {
        mem1 = a,   // エラー: ここには整数定数式が必要
        mem2,
        mem3
    } e;

メッセージ ID: notconst

## case ラベルには整数定数式が必要です

case ラベルには整数定数式が必要です。 このエラーメッセージを生成するコードの例を次に示します。

    int main()
    {
      int i = 0;

      switch (i) {
      case 4:	// ok
      case 3.141592654:	// エラー
          i++;
          break;
      };
    };

メッセージ ID: notconstcase

## 配列添字演算子の中では整数定数式が必要です

この配列添字演算子は整数定数だけを受け付けます。 このエラーメッセージを生成するコードの例を次に示します。

    int e[7];
    e[2.718281828] = 5; // エラー

メッセージ ID: notconstsub

## ビットフィールドには整数定数式が必要です

ビットフィールドには整数定数式が必要です。このエラーメッセージを生成するコードの例:

    class A {
      int a:2; // ok
      int b:6; // ok
      int d:3.141592654; // エラー
    };

メッセージ ID: notconstbit

## この構造が許可されるのは C++ だけです

`C++` にしか許可されないコードをコンパイラが検出し、この警告を発行しました。

メッセージ ID: notcpp

## typedef の名前は独自に作られた型指定子では使用できません

typedef の名前は、列挙型とクラス型では使用できません。 このエラーメッセージを生成するコードの例を次に示します。

    typedef struct S T;
    struct T *p; // エラー

    enum x { a, b }
    typedef enum x y;
    y x;      // ok
    enum y x; // エラー

メッセージ ID: notdclass

## 関数定義を typedef 宣言にすることはできません

関数定義を typedef された宣言にすることはできません。 このエラーメッセージを生成するコードの例を次に示します。

    typedef int(mft)(int i);
    mft foo
    {	// エラー
       return i + 2;
    }

メッセージ ID: notdfunc

## クラステンプレート名が予期される位置に〜があります

クラステンプレート名が予期されましたが見つかりませんでした。 このエラーメッセージを生成するコードの例を次に示します。

    int foo () { return 0; }

    template<> int foo(); // エラー: foo はテンプレートクラス名ではない

メッセージ ID: notempname

## テンプレートにパラメータが指定されていません

テンプレートを生成するオブジェクト型を指定するには、テンプレートクラス内にパラメータが必要です。 このエラーメッセージを生成するコードの例を次に示します。

    template<class T>
    class A {
      int i;
      T *data;
    public:
      A(int length=10) : data(new T[length]) {}
    };

    int main() {
      A a; // エラー: テンプレートにパラメータが必要
    return 0;
    }

メッセージ ID: notempparm

## テンプレート〜にインスタンス化引数が指定されていません

あるテンプレートクラスが引数をいくつか使用すると宣言されましたが、インスタンス化の時点で引数が 1 つも指定されていません。 このエラーメッセージを生成するコードの例を次に示します。

    template <class A>
    class B {};

    template class B<>; // エラー: テンプレート引数を指定する必要がある

メッセージ ID: notemparg

## 呼び出せるのは関数だけです

オブジェクトは呼び出せません。呼び出せるのは関数だけです。 このエラーメッセージを生成するコードの例を次に示します。

    void foo() {}

    int main()
    {
    	int i;
    	i(); // エラー: 呼び出せるのは関数のみ
    	foo(); // ok
    return 0;
    }

メッセージ ID: notfunc

## 宣言がタグまたは識別子を指定していません

宣言内にはタグか識別子が必要です。 このエラーメッセージを生成するコードの例:

    int;
    float;
    enum E;

メッセージ ID: nothingdecl

## 先行する〜の宣言には例外の指定があります

規格では、演算子 new に例外の指定が必要です。 この警告メッセージを生成するコードの例を次に示します。

    #include <new>

    // 正しい宣言:
    // void* operator new(size_t) throw(std::bad_alloc);

    void * operator new (size_t); // エラー

メッセージ ID: nothrownew

## 先行する〜の宣言には例外の指定があります (警告)

この演算子には以前に例外の指定がありました。ここでこの演算子が呼び出される場合、例外は送出されません。 この警告メッセージを生成するコードの例を次に示します。

    #include <stddef.h>
    void* operator new[] (size_t); // 警告: 演算子 new ならば "std::bad_alloc" を送出するはず

メッセージ ID: nothrowneww

## 先行する〜の宣言には例外の指定がありません

(互換モード) new 演算子の旧形式の宣言は例外の指定を使用しません。 このエラーメッセージを生成するコードの例 (互換モードの場合のみ):

    #include <new.h>

    void* operator new(size_t) throw(std::bad_alloc); // エラー: 演算子 new の
                                                      // 互換モードでは例外の指定が
                                                      // 禁止されている

メッセージ ID: nothrowold

## この case ラベルは switch 文の中にありません

case ラベルを使用できるのは switch 文の中だけです。 このエラーメッセージを生成するコードの例を次に示します。

    int main()
    {
    	int i = 7;

    	case 7:		// エラー: case 文が switch 文の中にない
    		i++;
    		break;

    return 0;
    }

メッセージ ID: notinsw

## この default ラベルは switch 文の中にありません

default ラベルを使用できるのは switch 文の中だけです。 このエラーメッセージを生成するコードの例を次に示します。

    int main()
    {
    	int i;

    	default:
    		i = 3;
    return 0;
    }

メッセージ ID: notinswdef

## 右側はメンバーポインタでなければなりません

\".*\" または \"->*\" の右側に使用されたポインタがメンバーポインタではありません。

    struct S {
    	  int i;
    };

    void foo()
    {
    	int y;
    	S cs;
    	int S::* pm = &S::i;	// pm はメンバー S::i を参照する
    	cs.*pm = 88;	        // Ok
    	cs.*y = 88;		// エラー: メンバーポインタではない
    				// ".*" または "->*" の右側はメンバーポインタでなければならない

    }

メッセージ ID: notmembptr

## 呼び出せるのは〜から導かれた関数だけです

呼び出せるのは `.*` または `->` から導かれた関数だけであり、そのアドレスを取得することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
        public:
            void foo () {}
    };

    void (A::* f_ptr) ();

    int main () {
        A a;
        f_ptr = A::foo;
        a.*f_ptr;       // エラー: 呼び出せるのは関数のみ。有効なコードは
                        //        (a.*f_ptr)();
    }

メッセージ ID: notmembcall

## 〜は名前空間でもクラスの名前でもありません

このエラーは、ユーザーが名前空間ではないものに対して名前空間の別名を作成しようとする場合に通常発生します。 このエラーメッセージを生成するコードの例を次に示します。

    struct not_a_namespace {};

    int main () {
        namespace alias=not_a_namespace; // エラー: 構造体の別名を作成しようとしている
    }

メッセージ ID: notnamespace

## 〜は以前に定義されましたが名前空間ではありません

この識別子はすでに使用されており、名前空間として再定義することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    int n;

    namespace n {  // エラー
            int i;
    };

メッセージ ID: notnsname

## 〜は定義されただけで使用されていません

宣言されただけでコード内で使用されていないオブジェクトをコンパイラが見つけ、この警告を発行しました。 この警告メッセージを生成するコードの例を次に示します。

    void foo() {
        int i; // i は使用されていない
    }
    void foobar( int a,	// a は使用されていない
    	     int b )	// b は使用されていない
    {}

メッセージ ID: notused

## type_info が定義されていません

`type_info` クラスを使用するには、ファイル `typeinfo.h` をインクルードする必要があります。プログラムが将来 RTTI サポートのために `typeinfo` クラスを使用すると予測される場合は、別の名前を選択することをお勧めします。

メッセージ ID: notypeinfoh

## 〜は名前空間の名前ではなくクラス名でなければなりません

using 宣言には、基底クラスであるクラス名が必要です。使用されたのは名前空間の名前でした。 このエラーメッセージを生成するコードの例を次に示します。

    namespace NS {int j; }
    //. . .

    class A: NS {
    	using NS::j;
    };

メッセージ ID: nsnotall

## 〜はクラス名ではなく名前空間の名前でなければなりません

using 指令には名前空間の名前が必要です。使用された名前はクラス型の名前でした。

    struct A{int j;};
    void foo()
    {
    	using A::j; // エラー: foo 内に名前空間が必要。
    }

メッセージ ID: nsnotcl

## ラベル〜は使用されていません

一度も使用されていないラベルをコンパイラが見つけ、この警告を発行しました。 この警告メッセージを生成するコードの例を次に示します。

    void foo() {
      int i = 0;
      goto b:
      a:
        --i;
      b:
        ++i;
    };

メッセージ ID: labelnotused

## 型の名前が予期される位置に〜があります

型の名前が予期されましたが見つかりませんでした。このエラーが発生する状況は多数あります。 このエラーメッセージを生成するコードの例:

    class A:   // エラー: 基底クラス名が抜けている
    {};

    struct B {
            int i;
    	j; // エラー: 型の名前が必要な位置に "j" がある
    };

    struct D : B, { // エラー:," の後、別の基底クラス名が必要
            int j;
            D() :   { j = 10; };
            // エラー: 型の名前が必要な位置に "{" がある。初期設定子が抜けている
    };

    template <class T, class K>
    class A {};

    A<int, > a; // エラー: コンマの後に型の名前がない

メッセージ ID: notypenameerr

## 定義済みマクロに対して #define と #undef は正当ではありません

定義済みマクロはコンパイラによって使用されるため、#define と #undef は行えません。

メッセージ ID: noundef

## 共用体は基底の型を持つことはできません

共用体を基底の型として使用することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    class C {
    	int i;
    };

    union B: C { // エラー
    	int j;
    };

メッセージ ID: nounionbase

## 共用体を基底の型として使用することはできません

共用体を基底の型として使用することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    union C {
    	int i;
    };

    union B: C { // エラー
    	int j;
    };

メッセージ ID: nounionasbase

## 共用体は仮想関数を持つことはできません

共用体は仮想関数を持つことはできません。 このエラーメッセージを生成するコードの例を次に示します。

    union A {
            int i;
            void foo() {};		// ok
    	virtual void foobar() {};	// エラー
    };

メッセージ ID: nounionvirt

## void 型の値は許可されていません

型データ `void` は値を持ちません。 このエラーメッセージを生成するコードの例を次に示します。

    foo()
    {
      int i = (void)1;
    }

メッセージ ID: novoidval

## void* を間接参照することはできません

`void` ポインタを間接参照することはできません。void は値を持ちません。 このメッセージを生成するコードの例を次に示します。

    void *i;
    int j = *i; // エラー: void* は間接参照できない

メッセージ ID: novoidderef

## while が予期される位置に〜があります

`do` ブロックは、`do-while` ループ内で `while` 文によって終了する必要があります。 このエラーメッセージを生成するコードの例を次に示します。

    void foo()
    {
    	int i = 0;
    	int j = 7;
    	do {
    	i++;
    	}  // エラー:"while" が必要な位置に "}" がある

    	i = 0;
    	do {
    	i++;
    	} while ( i < j); // ok
    }

メッセージ ID: nowhileerr

## クラス中で using 指令を使うことはできません

クラス中で using 指令を使うことはできません。 このエラーメッセージを生成するコードの例を次に示します。

    namespace NS { int j; };

    class A {
      using namespace NS;
    };

メッセージ ID: nsdirinclass

## 〜を NULL 値に初期化しています

参照の初期化式がゼロに評価されています。 このエラーメッセージを生成するコードの例を次に示します。

    static int zero;
    int& c = *(int*)0;  // 警告: 参照がゼロに初期化されている

メッセージ ID: nullref

## 初期設定子に基底クラスもメンバー名もありません

クラス名もメンバー名もない基底の初期設定は現在廃止されています。 このエラーメッセージを生成するコードの例を次に示します。

    struct A {
            int i;
    	A(int);
    };

    struct B: A {
            int j;
            B() : (3) { // エラー
    	   	j = 7;
    	};
    };

メッセージ ID: obsinit

## 関数定義の中で他のオブジェクトを宣言することはできません

関数定義は他のオブジェクトを宣言することはできません。他のオブジェクトを宣言できるのはクラス定義だけです。関数の後に他のオブジェクト宣言が続いていないかぎり、オブジェクトと共に関数を宣言してもこのエラーは発生しません。 このエラーメッセージを生成するコードの例を次に示します。

    int 	i,
    	foo() { // エラー: ここでは関数を宣言できない。
    		return 0;
    	} int j;

メッセージ ID: onlyonefunc

## 整数のオーバーフローまたは 0 による除算があります

式の `int` のサイズがオーバーフローしたか、0 による除算がありました。

メッセージ ID: overflow

## コンパイラでメモリー不足です

コンパイラでメモリーが不足です。リソースを一部解放し、再度試してください。

メッセージ ID: outofmem

## 〜の初期設定の括弧が完結していません

括弧を付けずに構造体メンバーの初期設定を行うと、"+w2" フラグでコンパイルを行う場合に警告が生成されます。 このエラーメッセージを生成するコードの例を次に示します。

    struct B {
      int i;
      int j;
    } X[] = { 1, 2, 3, 4 };

メッセージ ID: partinit

## この指令に対応する先行の #if がありません

`#else` 指令には、対応する先行の `#if` 指令がなければなりません。 このエラーメッセージを生成するコードの例を次に示します。

    //#if true
    #define num 1
    #else num 0
    // . . .

メッセージ ID: ppbadelse

## この #endif に対応する先行の #if がありません

プリプロセッサ指令 `#endif` には、対応する `#if` がなければなりません。

メッセージ ID: ppbadendif

## この行には余分なテキストがあります

プリプロセッサコマンドの後に、余分なテキストがあります。 このエラーメッセージを生成するコードの例を次に示します。

    #include <file.h>; // エラー: 余分な ";" を削除してください

メッセージ ID: ppextra

## ANSI C ではこの行の余分なテキストは許可されません。無視されました

この行の余分なテキストは ANSI C では無視されます。

メッセージ ID: ppextraw

## 後置演算子として〜を使用しています

宣言されたのは前置インクリメント演算子か前置デクリメント演算子だけです。後置演算子も使用前に宣言する必要があります。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    public:
    	int i;
            A operator ++(); // 前置演算子 ++ の宣言
    };

    int main()
    {
    	A a;
    	a++; // エラー: 後置演算子 ++ を多重定義して修正してください
    }

メッセージ ID: postincdec

## 関数プロトタイプで使用する前に〜を宣言してください

構造体型と列挙型は、関数プロトタイプで使用する前に宣言する必要があります。このメッセージは、コンパイラが C モードでコンパイルするように設定される場合に表示されます。

メッセージ ID: protodec

## 抽象クラス〜に対して変数を作成することはできません

1 つまたは複数の純粋仮想関数の抽象クラスは基底クラスとしてしか使用できません。抽象クラスのインスタンスを直接作成することはできません。派生クラスのオブジェクトを作成する必要があります。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
      virtual void foo() = 0;
      virtual int bar() = 0;
    };

    A a; // エラー

メッセージ ID: purealloc

## 抽象クラスのメンバーを宣言することはできません

抽象クラスはメンバーとして使用できません。このメンバーが派生クラスの場合、このクラスがすでに基底クラス内の純粋仮想関数をすべて定義してあることを確認してください。 このエラーメッセージを生成するコードの例を次に示します。

    class B {
      virtual void foo() = 0;
    };

    class X { B b; }; // エラー: B は抽象クラス

    template <class T>
    class Y {};
    Y<B> y; // エラー

メッセージ ID: puremem

## 抽象クラスのパラメータを持つことはできません

パラメータに抽象クラスは指定できません。

メッセージ ID: pureparm

## 抽象クラスの値を返すことはできません

戻り型に抽象クラスは指定できません。抽象クラスは実装されておらず、使用できません。戻り型指定が派生クラスの場合、このクラスがすでに基底クラス内の純粋仮想関数をすべて定義していることを確認してください。 このエラーメッセージを生成するコードの例を次に示します。

    class B {
      virtual B foo(B) = 0; // エラー: foo(B) が抽象クラスを返す
    };

    class A: B {};

    A bar() { // エラー
      A *a;
      return *a;
    }

メッセージ ID: purert

## 抽象クラスの値を作成することはできません

抽象クラスから値を作成することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
        public:
            virtual int foo () = 0;
    };

    class B : public A {
        public:
            virtual int foo () { return 0; };
    };

    int main () {
        B * b = new B();
        A& a = (A) *b;  // エラー: A は抽象クラス
    }

メッセージ ID: pureval

## 〜は置き換えられていません

基底クラスの純粋仮想関数が置き換えられる前に、抽象クラスの派生クラスの変数がインスタンス化されました。 このエラーメッセージを生成するコードの例を次に示します。

    class B {
      virtual void foo() = 0;
    };

    class A: B {};

    A a; // エラー

メッセージ ID: puref

## 〜は型修飾子を持つことができません

別のスコープを指定するために型修飾子を使用してメンバー関数を宣言することはできません。

    class A {
    };

    class B {
      void A::foo(); // エラー: 型修飾子は使用できない
      void B::goo(); // ok: goo() はクラス B で宣言されている
    };

メッセージ ID: qualnotok

## パラメータリストで許可される記憶クラスはレジスタだけです

パラメータリストでは記憶クラス `register` だけが許可されます。`static`、`extern`、および `mutable` は許可されません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
        void foo( register int a,// ok
    	    mutable int b, // エラー
    	    extern c,      // エラー
    	    static int d,  // エラー
    	    auto int e )   // ok
        {}
    };

メッセージ ID: registeronly

## 無名の共用体メンバー〜の名前がそれを含むクラスの名前と同じです

無名の共用体メンバーは、それを含むクラスと同じ名前を持つことはできません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
      union {
        int i;
        long j;
        int A;  // エラー
      };
    };

メッセージ ID: sameanon

## 列挙子〜の名前がそれを含むクラスの名前と同じです

列挙子は、それを含むクラスと同じ名前を持つことはできません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
      enum e { A, B, C }; // エラー
    };

メッセージ ID: sameenum

## 静的メンバーの名前がそれを含むクラスの名前と同じです

静的メンバーは、それを含むクラスと同じ名前を持つことはできません。このエラーメッセージを生成するコードの例:

    class A {
    	static int A;
    };

メッセージ ID: samestatic

## 〜型の名前がそれを含むクラスの名前と同じです

クラス内でクラスと同じ名前の型を定義することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
        typedef struct { int a; } A; // エラー: クラス A と typedef A は同じ名前を持つ
    };

メッセージ ID: sametype

## スカラー型の式が予期されています

この式はスカラー型でなければなりません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    public:
      A() { i = 0; }
      int i;
      A foo() { return *this; }
    };

    void foo() {
      A a;
      if( a ){ // エラー: scalar 型が必要な位置に型 A がある
      }

      for( a.i;
           a;    // エラー
           a.i++) {}
    }

メッセージ ID: scalarexpected

## sizeof をビットフィールドに適用することはできません

`sizeof` をビットフィールドに適用することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    public:
      A() { size = sizeof(i); }
      int i:3;
      int size;
    };

メッセージ ID: sizeofbf

## sizeof を関数に適用することはできません

`sizeof` を関数に適用することはできません。sizeof を適用できるのは、プリミティブ型、クラスオブジェクト、および式だけです。 このエラーメッセージを生成するコードの例を次に示します。

    int i;
    int j;
    int foo(int k);
    int goo();

    k = sizeof (i*j*foo(10));	 //ok
    k = sizeof (unsigned int);	 //ok

    k = sizeof(foo);		 // エラー
    k = sizeof(goo);		 // エラー

メッセージ ID: sizeoffunc

## 〜の静的変数、動的変数の両方を持つことはできません

多重定義された関数は、静的変数と動的変数の両方を持つことはできません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
      static void foo();
      void foo(); // エラー
    };

メッセージ ID: statnonconf

## この指定子はここでは許可されません

構文エラーです。この指定子はここでは許可されません。 このエラーメッセージを生成するコードの例:

    inline class A{}; // エラー
    virtual void foo(); // エラー

    void foo() {
      virtual  void f1(); // エラー
      friend void f2(); // エラー
      explicit void f3(); // エラー
    };
    void foo() {}

メッセージ ID: storenotok

## 〜は許可されないため、無視されます

使用されている指定子はここでは許可されないため、コンパイラによって無視されました。このメッセージは、テンプレートに対し typedef が試みられたときにも発行されます。 この警告メッセージを生成するコードの例を次に示します。

    template <class T> static class A; // 警告:"static" は許可されないため無視される

メッセージ ID: storenotokw

## 浮動小数点の減算にオーバーフローがありますが、処理は実行時に持ち越されました

浮動小数点数の減算がオーバーフローするとコンパイラが判断しました。このエラーの処理は実行時に持ち越されました。

メッセージ ID: subfovfl

## この case は、局所変数の初期設定を迂回しています

局所変数が迂回されており、初期設定を行うことはできません。 このエラーメッセージを生成するコードの例を次に示します。

    void foo()
    {
            int i=7;
            switch(i) {
            case 7:
                    break;
                    int j = 2;
            default:   // この case は局所変数 j の初期設定を迂回する
                    i = 8;
            }
    }

メッセージ ID: swuninit

## テンプレートパラメータ〜には型引数が必要です

このテンプレート引数に無効な型が指定されたか、あるいは引数が指定されていません。 このエラーメッセージを生成するコードの例を次に示します。

    template <class T, class K>
    class B {
    public:
      T t;
      K k;
    };

    B<int> b1; // エラー: B<T,K> にはもう 1 つのテンプレート引数が必要
    B<int, 12345> b2; // エラー: 12345 は有効でない

メッセージ ID: temargnotype

## テンプレートパラメータ〜には〜型の式が必要です

この式は、テンプレートパラメータの型と一致しません。オブジェクトへの型参照において型名でないテンプレートパラメータには変換が適用されません。 このエラーメッセージを生成するコードの例を次に示します。

    template <int i> class A {int i;};
    ;

    A<3.141593> a1; // エラー: int ではない引数
    A<3> a2; // ok

    template<class T, char* p> class D {
    	D();
            D(const char* q);
    };

    D<int,"penny"> x1; //  エラー: テンプレート引数としての文字列リテラル

    char p[] = "dime";
    D<int,p> x2;       //  OK

メッセージ ID: temargnoval

## NULL ポインタの変換はテンプレート引数に適用することはできません

不正な型を持つ実際のパラメータがテンプレートパラメータとして渡されました。通常、これは NULL ポインタがポインタ型のテンプレートパラメータとして渡されたことを意味します。NULL ポインタの変換はテンプレートパラメータに適用できないため、この場合、エラーが発生します。 このエラーメッセージを生成するコードの例を次に示します。

    template <char * i> class A {};

    int main () {
        A<0> a;
    }

メッセージ ID: tempargnullptr

## 関数テンプレートはデフォルトテンプレートパラメータを持つことはできません

デフォルトテンプレートパラメータが許可されるのは、クラステンプレートとクラスメンバー関数だけです。 このエラーメッセージを生成するコードの例を次に示します。

    template <class T=int>
    T foo();

メッセージ ID: temdefparms

## 型でないテンプレートパラメータは関数テンプレートには許可されません

型名でないテンプレートパラメータは、メンバーでない関数には許可されません。 このエラーメッセージを生成するコードの例を次に示します。

    template <int x>
    int foo();

メッセージ ID: temfuncnontype

## テンプレートの引数が多いため、〜から後は無視されました

テンプレートの引数が多すぎます。

メッセージ ID: temmanyargs

## テンプレートが宣言できるのはクラスまたは関数だけです

テンプレートはクラスと関数だけに使用されます。 このエラーメッセージを生成するコードの例を次に示します。

    template <class T>
    int i;

メッセージ ID: tempnotfunc

## テンプレートを宣言できるのは大域レベルでだけです

テンプレートを宣言できるのは大域レベルでだけです。 このエラーメッセージを生成するコードの例を次に示します。

    void foo() {
      int i;
      template <class T> class B { int j; }; // エラー
    };

メッセージ ID: temnotglob

## テンプレートの入れ子が深すぎます (再帰的になっていませんか ?)

テンプレートの入れ子の深さは 20 レベルまでしか許可されません。

メッセージ ID: temtoodeep

## 修飾子は〜には許可されません

メンバーは修飾できません。

メッセージ ID: tdefqual

## この例外指定は同じオブジェクト型を 2 つ含んでいます

この例外指定は同じオブジェクト型を 2 つ含んでいます。 この警告メッセージを生成するコードの例を次に示します。

    void foo() throw(float i, float j);

メッセージ ID: tltwice

## 〜は現在の例外指定中にはありません

この例外指定は、宣言以来変更されています。例外指定は一致する必要があります。 このエラーメッセージを生成するコードの例を次に示します。

    void foo() throw(int i);

    // . . .

    void foo() throw(float i) {} // エラー

メッセージ ID: tnotinnew

## 〜は先行の例外指定にはありません

先行の例外指定には、引数の現在の型は含まれていませんでした。例外指定は一致する必要があります。 このエラーメッセージを生成するコードの例を次に示します。

    void foo() throw();

    // . . .

    void foo() throw(float i ) {} // エラー

メッセージ ID: tnotinold

## 〜の呼び出し中の引数が少なすぎます

関数宣言に指定された数よりも少ない引数が関数呼び出しに指定されています。 このエラーメッセージを生成するコードの例:

    void foo( int i, int j ) {}

    int main()
    {
         foo(1); // エラー: foo() 呼び出しの引数の数が不足
    return 0;
    }

メッセージ ID: toofewargs

## マクロ〜中の引数が少なすぎます

マクロ定義に指定された数よりも少ない引数がマクロ呼び出しに指定されています。 この警告メッセージを生成するコードの例を次に示します。

    #define mask             0xffff00
    #define getField(data, mask)  data & mask // 引数を 2 つ持つと定義されたマクロ

    int field = getField( 1 ); // エラー: マクロ呼び出しに引数が 1 つしか指定されていない

メッセージ ID: toofewmargs

## テンプレートの引数が少なすぎます

このテンプレートは、指定された数を超える引数を持っています。 このエラーメッセージを生成するコードの例:

    template <class A1, class A2> class B {};

    int main () {
        B<int> b;
    }

メッセージ ID: toofewtargs

## 〜の呼び出し中の引数が多すぎます

関数宣言における数を超える引数が関数呼び出しに指定されています。 この警告メッセージを生成するコードの例を次に示します。

    void foo( int i, int j ) {}

    int main()
    {
    	foo( 1, 2, 3 )
    return 0;
    }

メッセージ ID: toomanyargs

## 〜へのキャスト中の引数が多すぎます

構文エラーが検出されました。キャスト式に渡された引数が多すぎます。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
        public:
            operator long ();
    };

    int main () {
        long t = long(A(), 0); // エラー: long へのキャストに使用されている引数が多すぎる
                               // 次のように指定すべき:
                               // long t = long(A());
    }

メッセージ ID: toomanycargs

## マクロ〜中の引数が多すぎます

マクロで定義されている数を超える引数がマクロ呼び出しに指定されています。 このエラーメッセージを生成するコードの例を次に示します。

    #define mask             0xff0000
    #define getField(data,mask)  data & mask   // 2 つの引数を使用して定義されたマクロ

    int field = getField( 1, 2, mask ); // マクロ呼び出しに 3 つの引数が指定されている

メッセージ ID: toomanymargs

## 〜の初期設定子が多すぎます

コンストラクタ初期設定子は 1 つのパラメータしか受け付けません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
      int i;
      A(): i(1,2) {}
    };

メッセージ ID: toomanynargs

## テンプレートの引数が多すぎます

テンプレートの引数が多すぎます。 このエラーメッセージを生成するコードの例を次に示します。

    template< class T, class K > // 2 つのテンプレートパラメータ
    class A {
      T t;
      K k;
    };

    A<int, float, long> a; // エラー: 3 つのテンプレート引数

メッセージ ID: toomanytargs

## アクセスは公開または限定公開にしか変更できません

クラスメンバーのアクセスレベルは非公開には変更できません。アクセスは公開または限定公開にしか変更できません。 このエラーを生成するコードの例:

    class A {
      public: int i;
    };

    class B: A {
      private: A::i;
    };

メッセージ ID: topubliconly

## 〜は 2 回初期化されています

値が 2 回初期化されました。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    public:
      static const int j = 9;
      A() {}
    };
    const int A::j = 9; // A::j は 2 回初期化された

メッセージ ID: twoinits

## 〜は複雑すぎます

この式は複雑すぎます。 このエラーメッセージを生成するコードの例を次に示します。

    void foo(){
      int **************************i;
      **************************i = 9; // エラー: 複雑すぎる。"*" が 26 個
    }

メッセージ ID: twtoocomp

## 予期しない型名〜がありました

この型名は、関数またはクラスの使用前に定義されていません。 このエラーメッセージを生成するコードの例を次に示します。

    template<class T>
    class A {
    	T t;
    };

    class B{
    	int i;
    };

    int main() {
    	A<float> a; // ok
     	B<int> b; // エラー: 型 B に対しテンプレートが定義されてない
    }

メッセージ ID: typenotall

## 変数〜には値が代入されていません

値が代入されていない変数が使用されました。 この警告メッセージを生成するコードの例を次に示します。

    void foo()
    {
    	int i;
    	i++;
    }

メッセージ ID: unassigned

## 〜は定義されていません

識別子が使用されましたが、定義されていません。 このエラーメッセージを生成するコードの例を次に示します。

    void foo()
    {
      int i;
      j++; // エラー: j は定義されていない
    }

メッセージ ID: undefidenterr

## テンプレート〜は定義されていません

テンプレートは、テンプレート型パラメータとして使用する前に定義する必要があります。このエラーメッセージを生成するコードの例:

    template <t_arg<int> > struct tmp {};   // エラー: t_arg は定義されていない

メッセージ ID: undeftemperr

## 比較の結果が使用されていません

比較の結果が使用されていません。 この警告メッセージを生成するコードの例を次に示します。

    void foo()
    {
      int i = 9;
      i == 9; // 警告: 結果が使用されていない
    	i++;
    }

メッセージ ID: unusedcomp

## コンストラクタを仮想にすることはできません

仮想コンストラクタは許可されません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
            int a;
            virtual A(); // エラー
    };

メッセージ ID: virtconstr

## 仮想のフレンド関数では修飾するクラス名が必要です

仮想のフレンド関数では修飾するクラス名が必要です。 このエラーメッセージを生成するコードの例を次に示します。

    void foo() { return; }
    void goo() { return; }

    class A {
            virtual friend void foo();    // エラー
    	virtual friend void A::goo(); // ok
    };

メッセージ ID: virtfriend

## 〜は値を戻すことを期待されています

関数が値を返すことを期待されていますが、void を返しています。 このエラーメッセージを生成するコードの例を次に示します。

    int foo()
    {
    	return; // エラー: int 型を返すと期待されている
    }

メッセージ ID: voidret

## "&" 演算子を適用できるのは変数またはその他の左辺値だけです

アドレス演算子を適用できるのは変数または左辺値だけです。該当するアドレスが存在しなければなりません。 このエラーメッセージを生成するコードの例を次に示します。

    int *i = &3; // エラー:"3" は左辺値ではない

メッセージ ID: wantvarname

## ANSI C ではビットフィールドは符号付きまたは符号なし整数でなければなりません

ANSI C でサポートされるのは、符号付きまたは符号なし整数のビットフィールドだけです。

メッセージ ID: wbadbftype

## 〜は以前に〜ではなく〜と宣言されています

演算子 new または演算子 delete には異なるリンケージが必要です。 この警告メッセージを生成するコードの例を次に示します。

    #include <new>

    // 警告: new は静的であってはならない (new は外部と宣言された)。
    static void* operator new(size_t) throw(std::bad_alloc);

メッセージ ID: wbadlinkage

## 宣言が空です (余分なセミコロンがあると考えられます)

宣言が空です。余分なセミコロンがあると考えられます。 このエラーメッセージを生成するコードの例を次に示します。

    ; // 警告: 宣言がない

    namespace NS{}; // 警告: 名前空間 NS の最後に余分なセミコロンがある

    }; // エラー: 右括弧に対応するものがない

メッセージ ID: wemptydecl

## 宣言がタグまたは識別子を指定していません

(K&R): 宣言内にタグまたは識別子が必要です。 このエラーメッセージを生成するコードの例:

    struct {};  // エラー

メッセージ ID: wnothingdecl

## 〜を〜に代入しています

互換性のない型に型が代入されました。クラスオブジェクトの型には、コンストラクタ、変換関数、多重定義された代入演算子などが必要な場合があります。 この警告メッセージを生成するコードの例を次に示します。

    class B {
    	int i;
    };

    class A: B {
    	int j;

    };

    void foo()
    {
    	A a;
    	B b;
    	a = b; // エラー
    	b = (B)a; // エラー: 型 B に対するコンストラクタまたは変換関数が A に存在しない

    	A *pa = &a;
    	B *pb;
    	pb = (B*)pa; // ok: pa* は基底クラスへのポインタに対するキャスト
    }

メッセージ ID: wbadasg

## 代入で文字列リテラルを char* に変換しました

代入で文字列リテラルを char* に変換しました。 この警告メッセージを生成するコードの例を次に示します。

    void foo () {
        char *s;
        s  = "abcd"; // 警告
    }

メッセージ ID: wbadasgl

## 〜を使用して〜を初期化しています

異なる型を使用して型を初期化しているために警告が出力されました。

メッセージ ID: wbadinit

## L を使用して〜を初期化しています

文字列リテラルを使用して異なる互換型が初期化されました。

    void foo()
    {
      char * s = "f"; // 警告: const char* を使用して E を初期化している
    }

メッセージ ID: wbadinitl

## 〜は値を戻すことを期待されています

(K&R): この関数は値を戻すと宣言されていますが戻していません。 このエラーメッセージを生成するコードの例を次に示します。

    int foo()
    {
    	return; // エラー: foo() は値を戻す必要がある
    }

メッセージ ID: wvoidret

## 〜が〜を隠してます

関数内の変数がクラスメンバーの名前を隠しています。 この警告メッセージを生成するコードの例を次に示します。

    class A {
            int i;

            void foo() {
                    int i; // 警告: i が A::i を隠している
            }
    };

メッセージ ID: wvarhidemem

## 〜は有効範囲外で同じ名前を隠しています

この変数は、有効範囲外で変数名を隠しています。 この警告メッセージを生成するコードの例を次に示します。

    void foo() {
      int i;
      for ( int i = 0; // 警告: i は有効範囲外で変数を隠している。
    	i < 10;
    	++i ){};
    }

メッセージ ID: wvarhidenmem

## #pragma init/fini の〜は引数を持たない void 関数であるべきです

init プラグマまたは fini プラグマにパラメータとして渡せるのは引数を持たない void 関数だけです。 このエラーメッセージを生成するコードの例を次に示します。

    void my_fini (int a) { }
    #pragma fini(my_fini)

メッセージ ID: prbadfunc

## #pragma のリストが空です

一部のプラグマは、1 つ以上のパラメータが渡されることを要求します。 このエラーメッセージを生成するコードの例を次に示します。

    #pragma fini ()

メッセージ ID: premptylist

## 境界整列が無効です。有効な値は以下のとおりです。 1、2、4、8、16、32、64、128 です

境界整列で指定する値は、128 を最大とする、負でない 2 の整数乗数でなければなりません。 このエラーメッセージを生成するコードの例を次に示します。

    #pragma align 256 ( an_int, a_ptr, a_struct, a_class )

メッセージ ID: prbadalign

## 〜は関数として宣言されていません

一部のプラグマは、それらの引数が関数であることを要求します。 このエラーメッセージを生成するコードの例を次に示します。

    int my_fini;
    #pragma fini(my_fini)   // エラー: my_fini は関数ではない

メッセージ ID: prnotfunc

## #pragma で参照されている〜は大域的として前もって宣言されている必要があります

関数がプラグマパラメータリストに出現する場合、その関数を前もって宣言しておく必要があります。 このエラーメッセージを生成するコードの例を次に示します。

    #pragma fini(my_fini)   // エラー: my_fini は前もって宣言されていなければならない
    void my_fini (int a) { }

メッセージ ID: prnotdecl

## プラグマに構文エラーがあります

プラグマ文が不正です。指定すべきプラグマ引数が省略されている可能性があります。 このエラーメッセージを生成するコードの例を次に示します。

    int a, b, c;
    #pragma align (a, b, c)

メッセージ ID: prsyntax

## #pragma ident の後には文字列リテラルがあるべきです

`#pragma ident` の後に文字列リテラルが抜けています。

メッセージ ID: prnostr

## #pragma リストに "," が抜けています

プラグマ引数の区切り文字として不正な記号が使用されました。 このエラーメッセージを生成するコードの例を次に示します。

    void my_init1 () { }
    void my_init2 () { }
    void my_init3 () { }

    #pragma init(my_init1,my_init2.my_init3)

メッセージ ID: prnocomma

## #pragma に "(" が抜けています

プラグラマパラメータリストは、'(' で始まる必要があります。 このエラーメッセージを生成するコードの例を次に示します。

    void my_init1 () { }

    #pragma init my_init1)

メッセージ ID: prnolp

## #pragma に ")" が抜けています

パラメータリスト内に ')' が抜けているか不正な記号が検出されました。 このエラーメッセージを生成するコードの例を次に示します。

    void my_init1 () { }
    void my_init2 () { }
    void my_init3 () { }

    #pragma init(my_init1,my_init2.my_init3)

メッセージ ID: prnorp

## 行番号

このメッセージは、エラーメッセージと共に行番号を表示するためにコンパイラによって使用されます。

メッセージ ID: linetheword

## Asm 文に文字がありません

`asm` 文には文字列リテラルがなければなりません。 このエラーメッセージを生成するコードの例を次に示します。

    void foo()
    {
      asm( nop ); // エラー
    }

メッセージ ID: noasmstring

## Asm 文は関数の外では許可されません

`asm` 文は関数の外では許可されません。 このエラーメッセージを生成するコードの例を次に示します。

    asm(" nop  "); // エラー

    void foo()
    {
      asm(" nop "); // ok
    }

メッセージ ID: asmnotinfunc

## フラグ〜には値が必要です

指定されたフラグには値が必要です。

メッセージ ID: cmd_needvalue

## 警告: フラグ〜はフラグ〜と同時には使用できません

一部の CC フラグは同時には指定できません (+e0 と -compat=5 など)。

メッセージ ID: cmd_badflag

## 入力ファイルがありません

このエラーは入力ファイルが渡されていない場合に ccfe によって発行されます。

メッセージ ID: noinpfile

## 入力ファイルを開けませんでした

コンパイラに渡されたファイルは存在しないかアクセス不能であるため開けませんでした。

メッセージ ID: openinpfile

## 出力ファイルを開けませんでした

プリプロセッサは出力ファイルを開けません。ファイルのアクセス権またはディスクの空き容量 (あるいはこの両方) を調べてください。

メッセージ ID: openoutfile

## ファイル中の最後の行が復帰改行で終わっていません

この警告は、ファイルが復帰改行で終わっていないことを示します。

メッセージ ID: nonewline

## クラスの外では mutable は許可されません

キーワード `mutable` はクラスの外では使用できません。mutable は、`const` と宣言されたクラスオブジェクト内のフィールドを変更できるようにするために使用します。 このエラーメッセージを生成するコードの例を次に示します。

    void foo()
    {
    	mutable int i = 0; // エラー
    }

    class A {
    	mutable int i; // ok
    };

メッセージ ID: mutclassonly

## 関数は mutable と宣言することはできません

`mutable` を使用できるのはメンバーデータに対してだけです。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    public:
      mutable int i; //ok
      mutable void foo() {} // エラー
      A() {}
    };

メッセージ ID: mutnofunc

## 定数の名前を mutable と宣言することはできません

`const` と宣言された名前を同時に mutable と宣言することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    public:
      A(int j) { i = j; };
      mutable const int i; // エラー
    };

メッセージ ID: mutnoconst

## 静的でないデータメンバーのみ mutable にできます

静的データメンバーは mutable にはできません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    public:
      mutable static int i;
    };

メッセージ ID: mutdatamems

## 〜は C++ 言語として宣言されなければなりません

多重定義された演算子は `C++` 言語として宣言されなければなりません。

    class A {};
    extern "C" A& operator *(A&, A&);

メッセージ ID: mustbecpp

## 完全なクラスの定義はフレンド宣言では許可されません

フレンド宣言ではクラス定義は指定できません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
        friend class B {}; // エラー: フレンド宣言におけるクラス定義
    };

メッセージ ID: nofrienddef

## 〜の後にコロンがありません

クラスメンバーのアクセスレベル指定の後にコロンがありません。ここでは、private、protected、および public の後にコロンが必要です。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
      public	// エラー:

    };

メッセージ ID: nocolaftacc

## マクロの引数中でファイルの末尾に到達しました

マクロの引数の最後が検出される前にファイルの末尾に到達しました。

    #define foo( A, B, C )
    foo(1, 2,     // エラー: 引数が抜けている。
    <EOF>

メッセージ ID: eofinmargs

## C++ では暗黙の int はサポートされていません

`C++` では、暗黙の int で宣言された変数はサポートされていません。 型を指定する必要があります。 この警告メッセージを生成するコードの例を次に示します。

    i[] = {1, 2, 3};

メッセージ ID: noimplint

## 〜より前に class か struct が必要です

テンプレート宣言内に class キーが必要です。このエラーは、クラステンプレート宣言のように見える不正な関数テンプレート宣言でも発生します。 このエラーメッセージを生成するコードの例を次に示します。

    template <class T> A // エラー: class キーが抜けている
    {
      int i;
      int j;
    };

    template <class T> foo : /* . . . */ ; // エラー

メッセージ ID: noclasskey

## 局所的な型はテンプレートの引数として使用できません

局所的に定義された型はテンプレートの引数として使用できません。 このエラーメッセージを生成するコードの例を次に示します。

    template <class T>
    class A{};

    void foo()
    {
    	class B {};
    	enum E {one, two, three};
    	A<B> a1; // エラー
    	A<E> a2; // エラー
    }

メッセージ ID: nolocaltarg

## テンプレート引数は名前のない型にはできません

テンプレート引数は名前のない型にはできません。テンプレート引数内で同時に型を定義することもできません。 このエラーメッセージを生成するコードの例を次に示します。

    template <class T>
    class A {
      T t;
    };

    A<class{}> a;	// エラー: 構造体に型名がない

    				// ユーザー定義の型を使用するには、使用前に型を定義してください

メッセージ ID: nounnamedtarg

## 初期化設定子のリストに予期しない〜があります

コンストラクタの初期化設定子リストの解析中に構文エラーが検出されました。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
        int a;
        long b;
        int c[2];

        A() : a(0) : b(0) {}    // エラー: 初期化設定子リストに予期しない ':' が検出された
    };

メッセージ ID: unexpinitl

## クラスファイルの書式に誤りがあります。〜でデッドコード

これは、Java Native Compiler が使用する内部メッセージです。

メッセージ ID: jdeadcode

## ファイルが見つかりませんでした

これは、Java Native Compiler が使用する内部メッセージです。

メッセージ ID: jnoclass

## 定義が見つかりませんでした

これは、Java Native Compiler が使用する内部メッセージです。

メッセージ ID: jnomember

## クラスファイルの書式に誤りがあります。定数のプール〜

これは、Java Native Compiler が使用する内部メッセージです。

メッセージ ID: jbadcpool

## クラスファイルの書式に誤りがあります。型コード〜

これは、Java Native Compiler が使用する内部メッセージです。

メッセージ ID: jbadtcode

## クラスファイルの書式に誤りがあります。不当なバイトコード

これは、Java Native Compiler が使用する内部メッセージです。

メッセージ ID: jbadbcode

## エクスポートは無視されました -- まだ実装されていません

`export` は無視されました。まだ実装されていません

メッセージ ID: exportnotimpl

## テンプレートキーワードが抜けています

テンプレート宣言の "<" の前にキーワード `template` が見つかりません。 このエラーメッセージを生成するコードの例を次に示します。

    export <class T>  // エラー
    class A{};

メッセージ ID: notemplkey

## 古い明示的な特殊化の構文

古い明示的な特殊化構文が検出され、この警告が発行されました。 新しい明示的な特殊化構文は次のとおりです。 template-id: template-name < template-argument-listopt > template-name: identifier template-argument-list: template-argument template-argument-list , template-argument template-argument: assignment-expression type-id id-expression

メッセージ ID: oldexpspecial

## クラスまたは関数以外の明示的なインスタンス化と特殊化は、まだ実装されていません

このコンパイラでは、クラスまたは関数以外の明示的なインスタンス化と特殊化はまだ実装されていません

メッセージ ID: noexpimpl

## operator-> を使用中に無限の再帰

クラスが "->" 演算子を多重定義しました。この演算子はクラス型の値を返します。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
    public:
      int j;
      A operator->(); // A を返す
    };

    void foo() {
      A a;
      a->j = 9; // エラー
    };

メッセージ ID: recurarrow

## 多重定義されたこの演算子はポインタを返す必要があります

多重定義された operator-> はクラス型のオブジェクトへのポインタを返す必要があります。 このエラーメッセージを生成するコードの例を次に示します。

    class B {
    public:
      int j;
      B operator->(); // B を返す
      B& operator->();
    };

    void foo() {
      B b;
      b->j = 7; // エラー: あいまい。operator->() は B を返す
    };

メッセージ ID: recurarrow2

## 〜への疑わしい戻り型

多重定義された "->" 演算子は、クラス型のオブジェクトへのポインタを返す必要があります。 この警告メッセージを生成するコードの例を次に示します。

    class A {
    public:
      int* operator->(); // 警告 A::operator->() は int* を返す
      int k;
    };

メッセージ ID: arrowrtn

## 〜から〜にキャストできません

関数ポインタとオブジェクトポインタ間のキャストに未定義の結果が生じました。Solaris 上では情報は保持されます。

メッセージ ID: badcastw

## クラスの中の無名の共用体は〜にはできません

クラスの中の無名の共用体は extern、static などの指定子を持つことができません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
        static union {  // エラー: 無名の共用体は static にはできない
            int a;
            long b;
        };
    };

メッセージ ID: badclanon

## 名前空間はクラスのスコープ内では宣言できません

クラス内における名前空間宣言は許可されていません。このエラーメッセージを生成するコードの例:

    class A {
        namespace ns {} // エラー: クラスのスコープ内における名前空間宣言
    };

メッセージ ID: noclassns

## テンプレートパラメータはこのスコープ内では再宣言できません

テンプレートパラメータはこのスコープ内では再宣言できません。テンプレートスコープ内の宣言でテンプレートパラメータの名前が使用された可能性があります。 このエラーメッセージを生成するコードの例を次に示します。

    template <class t_arg> class A {
        int t_arg;      // エラー: テンプレートパラメータ t_arg が再宣言されている
    };

    int main () {
        A<int> a;
    }

メッセージ ID: templparamdecl

## テンプレートパラメータは、独自に作られた型指定子では使用できません

テンプレートパラメータは、独自に作られた型指定子では使用できません。 このエラーメッセージを生成するコードの例を次に示します。

    template <class t_arg> class A {
        class t_arg {};     // エラー: 独自に作られた型指定子でテンプレートパラメータ t_arg が使用されている
    };

    int main () {
        A<int> a;
    }

メッセージ ID: templtypedecl

## 独自に作られた型指定子への不当な構文

構文エラーが検出されました。 このエラーメッセージを生成するコードの例を次に示します。

    template <class t_arg> class A {};

    typedef class A<int> my_type;   // エラー: 不当な構文 ...

メッセージ ID: badelabtype

## プラグマ pack への値は 2 の乗数でなければなりません

プラグマ pack への有効な値は 2 の乗数です。 このエラーメッセージを生成するコードの例を次に示します。

    #pragma pack (3)

メッセージ ID: prbadpack

## テンプレート宣言では extern C 型のリンクを持つことができません

extern C リンケージを使用してテンプレートを宣言することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    extern "C"
    template <class t_arg> class A {}; // エラー: テンプレート宣言はこのリンケージを持つことができない

メッセージ ID: temnotexternc

## テンプレートパラメータで修飾された型名には typename が必要です

型名がテンプレートパラメータで修飾される場合、`typename` キーワードが必要です。このエラーメッセージを生成するコードの例:

    class A {
        public:
            typedef int my_type;
    };

    template <class t_arg> class B {
        public:
            typedef t_arg::my_type my_type; // 警告
    };

    int main () {
        B<A>::my_type c;
    }

メッセージ ID: typenameass

## 〜からのあいまいなキャスト

このキャストはあいまいです。 このエラーメッセージを生成するコードの例を次に示します。

    class A {};

    class B : public A {};
    class C : public A {};

    class D : public B, public C {};

    int main () {
        D *d = new D;
        A *a = (A*) d; // エラー: D に 2 つの A インスタンスが含まれる
    }

メッセージ ID: ambigcast

## テンプレート〜のフレンド宣言は許可されません

特殊化を指定することなくテンプレートをフレンドとして宣言することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    template <class t_arg> class A {};

    class B {
        friend class A; // エラー: フレンドテンプレート宣言。下記が正しい
                        // friend class A;
    };

メッセージ ID: nofriendtmpl

## friend 宣言は関数テンプレートと両立しません

テンプレート関数はフレンドとして宣言できません。 このエラーメッセージを生成するコードの例を次に示します。

    template<class t_arg> int foo () { return t_arg; }

    class A {
        friend int foo<int>(); // エラー: テンプレート関数はフレンドにはできない
    };

メッセージ ID: nofunctmpl

## 大域的なスコープには〜への宣言がありません

大域的なスコープ内にフレンドと宣言された関数が見つかりません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
        friend int ::foo ();    // エラー: foo は大域的なスコープで宣言されていない
    };

メッセージ ID: noglobaldecl

## 警告: フラグ〜はフラグ〜と同時には使用できません

一部の CC フラグは同時には指定できません (+e0 と -compat=5 など)。

メッセージ ID: cmd_badflag_wrn

## エラー: フラグ〜はフラグ〜と同時には使用できません

一部の CC フラグは同時には指定できません (-memtmpl と -compat=5 など)。

メッセージ ID: cmd_badflag_err

## ビットフィールドへの定数でない参照を持つことはできません

ビットフィールドへの参照が定数ではありません。このエラーメッセージを生成するコードの例:

    struct C {
            int x : 2 ;
    };

    C oc;
    int & xref = oc.x;   // エラー: xref は定数でない参照

メッセージ ID: varbitref

## 事前にインスタンス化されたシンボルを読むために、ライブラリを開くことができませんでした

オプション -preinstlib=<file-name> で指定されたファイルを開くことができませんでした。

メッセージ ID: openinstlib

## 事前にインスタンス化されたライブラリからシンボルを読むことができませんでした

オプション -preinstlib=<file-name> で指定されたファイルからシンボルを読むことができませんでした。

メッセージ ID: readinstlib

## メンバー関数はテンプレート型パラメータとして宣言することはできません

関数型テンプレートのパラメータを使用したメンバー関数宣言が試みられました。 このエラーメッセージを生成するコードの例を次に示します。

    template <class T> struct X { T t; };

    typedef int F();
    X < F > m1; // エラー: 't' を int t() としては宣言できない

メッセージ ID: badtmplfunctyp

## 型でないテンプレート引数は型〜を持つことはできません

型でなくテンプレートでもないテンプレートパラメータに対するテンプレート引数は、指定された型を持つことはできません。詳細は、ISO C++ Standard 14.3.2 を参照してください。 このエラーメッセージを生成するコードの例を次に示します。

    template<class T, int I> class X { };

    X<int, 2.7> x;

メッセージ ID: badtmplexparg

## 文字列リテラルはテンプレート引数としては受け付けられません

文字列リテラル (lex.string) はテンプレート引数としては受け付けられません。これは、文字列リテラルが内部リンケージを使用したオブジェクトであるためです。詳細は、ISO C++ Standard 14.3.2 を参照してください。 このエラーメッセージを生成するコードの例を次に示します。

    template<class T, char* p> class X { };

    X<int,"String"> x;

メッセージ ID: tmplexpstrlit

## 配列要素のアドレスは利用できるテンプレート引数としては受け付けられません

配列要素のアドレスおよび静的でないクラスメンバーの名前またはアドレスは、利用できるテンプレート引数としては受け付けられません。詳細は、ISO C++ Standard 14.3.2 を参照してください。 このエラーメッセージを生成するコードの例を次に示します。

    template<int* p> class X { };

    int a[10];

    X<&a[2]> x;

メッセージ ID: tmplexpaddarr

## 〜の部分特殊化があいまいです

ユーザーが、複数の部分特殊化に対応する実際のテンプレート引数リストを指定しました。 このエラーメッセージを生成するコードの例を次に示します。

    template<class T1, class T2, int I> class A             { };

    template<class T1, class T2, int I> class A<T1*, T2, I> { }; // #1
    template<class T1, class T2, int I> class A<T1, T2*, I> { }; // #2

    A<int*, int*, 2> a5; // あいまい: #1 と #2 に対応する

メッセージ ID: ambigpartial

## 部分特殊化の主要な特殊化がありません

部分特殊化に先立つ主要な特殊化がありません。部分特殊化を宣言または定義するには、常に主要な特殊化を指定する必要があります。 このエラーメッセージを生成するコードの例を次に示します。

    template<class T>            class A<T, T*>   { };

    template<class T1, class T2> class A          { };

メッセージ ID: psnoprimary

## 部分特殊化はデフォルトの引数を持つことはできません

特殊化のテンプレートパラメータリストは、デフォルトのテンプレート引数値を含むことはできません。これは、それらを使用する方法がないためです。 このエラーメッセージを生成するコードの例を次に示します。

    template<class T1, class T2> class A             { };
    template<class T = int>                  class A<T, T*>   { };

メッセージ ID: psdefaults

## 型のないパラメータは式の一部として使用することはできません

型のないパラメータは式の一部として使用することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    template<class T, int p, int c> class X { };

    template<class T, int p > class X<T, p, p + 5> { };

メッセージ ID: psntinexpr

## 部分特殊化は同一の引数を持っています

この部分特殊化に主要な特殊化と同一の引数を指定してはなりません。これは、このような構成体を使用する方法がないためです。 このエラーメッセージを生成するコードの例を次に示します。

    template<class T1, class T2>  class A           { };
    template<class T1, class T2 > class A<T1, T2>   { };

メッセージ ID: pssameargs

## 特殊化された引数の型は別の引数に依存しています

型ではない特殊化された引数に対応するテンプレートパラメータの型は、その特殊化のパラメータに依存してはなりません。 このエラーメッセージを生成するコードの例を次に示します。

    template< int X, int (*array_ptr)[X] > class A {};

    int array[5];

    template< int X > class A<X,&array> {};

メッセージ ID: psargdeptype

## 部分特殊化のパラメータ〜が引数で使用されていません

1 つ以上の部分特殊化パラメータが指定されましたが、特殊化自体でそれらが使用されていません。 このエラーメッセージを生成するコードの例を次に示します。

    template<class T1, class T2> class A             { };
    template<class T, class T2>  class A<T, T*>      { };

メッセージ ID: psargnotused

## 部分特殊化は実装されていません

このメッセージは、ユーザーが部分特殊化処理を明示的に無効にする場合に発行されます。 このエラーメッセージを生成するコードの例 (互換モードの場合のみ):

    template<class T1, class T2> class A          { };
    template<class T>            class A<T, T*>   { };

メッセージ ID: psnotimp

## 一部の識別子は 'using' 宣言で使用できません

このエラーメッセージを生成するコードの例:

    class B
    {
    public:
        B() : i(0) { }
        ~B() { }
        int i;
    };

    class D : public B
    {
    public:
        using B::~B; // エラー - using はデストラクタを参照できない
        D() : j(0) { }
        int j;
    };

    int main()
    {
        return 0;
    }

メッセージ ID: usingdestr

## 〜のテンプレートデータベースはこのコンパイラと互換性がありません

コンパイラが、このコンパイラと互換性のない SunWS_cache ディレクトリを検出しました。このエラーは、古いコンパイラがそれよりも新しいコンパイラによって生成されたテンプレートデータベースを検出する場合に発行されます。 新しいコンパイラを使用してソースをコンパイルするか、あるいは `CCadmin -d -clean` を使用してそのテンプレートデータベースを整理してください。

メッセージ ID: tdb_version

## -I- オプションが重複しており、無視されました

コマンド行上に複数の -I- オプションが見つかりました。

メッセージ ID: duplicate_i

## 明示的なインスタンス化で推測される型に対応するテンプレートが見つかりませんでした

このエラーメッセージを生成するコードの例:

    template < class T > void copy ( T to ) { }

    template int copy ( long ) ;    // エラー !

メッセージ ID: badexplctinst

## クラスメンバーにそのクラスと同じ名前が指定されています

このエラーメッセージを生成するコードの例:

    struct x {
        x();
        int x;
    };

メッセージ ID: samemem

## 未完の列挙のメンバーに sizeof を指定しています

列挙子がすべて宣言されていない列挙型に sizeof 演算子を適用してはなりません。 このエラーメッセージを生成するコードの例:

    int mymain()
    {
        enum E { A, B = sizeof A }; // エラー - sizeof A をまだ適用できない
        return 0;
    }

メッセージ ID: badenumsize

## 互換性のない配列型にポインタを代入しています

`C++` では、完全な配列型へのポインタを不完全な配列型へのポインタに代入することは不当です (この逆も同様)。 このエラーメッセージを生成するコードの例:

    extern int a_39W73zz[2];   // サイズは判明している
    int (*p2)[] = &a_39W73zz;  // エラー - 型の不一致。`p2` のサイズは不明。

メッセージ ID: badarrptr

## 戻り値の型〜が完了していない関数〜。この状況では、コンパイラは仮想テーブルを生成できません

コンパイラは仮想関数の戻り値の型が定義を持たない構造体型である状況を処理できないため、コードを拒否します。 このエラーメッセージを生成するコードの例:

    struct Fum; // 不完全な型
    struct B {
            Fum virtual f();
    };
    struct D : virtual B {
            D();
    };
    D::D() { }

メッセージ ID: incompletert

## アクセスを変更できません

この方法で、メンバーへのアクセスを変更することはできません。このメッセージは、互換モードの場合は警告ですが、標準モードの場合はエラーです。 このエラーメッセージを生成するコードの例を次に示します。

    class C {
    private:
        class inner;
    public:
        class inner { }; // 別のアクセスで再定義する必要がある
    };

メッセージ ID: badaccadjw

## 〜と〜の間の多重定義にあいまいさがあります

多重定義で呼び出された関数があいまいです。 このエラーメッセージを生成するコードの例を次に示します。

    void foo (int i, int j);
    void foo (int i = 3, int j = 7);//  ok:  foo(int, int) の宣言
    void foo ();                    //  ok:  foo の宣言

    int main()
    {
    	foo (1, 2);             //  ok:  f(int, int) の呼び出し
            foo ();                 //  エラー: f(int,int) と f() のどちらを呼び出すか不明
    }

あいまいさはコンストラクタと変換演算子の使用によっても起こることがあります。

    struct A { A(int); };
    struct B {
    	B(int);
    	operator int();
    	operator double();
    } b;

    A foo( A a );
    B foo( B b );

    int main()
    {
      foo(1); // エラー: foo(A) と foo(b) のどちらか不明
    }

    int i = b;
     // ok: 一致する int にB を変換
    float f1 = b; // エラー: int 演算子と double 演算子のどちらを呼び出すか不明
    float f2 = double(b);
     // ok: 変換演算子の指定

メッセージ ID: manymatchover_w

## 〜は〜からはアクセスできません

クラス内の非公開メンバーへ直接のアクセスを試みました。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
            int i; // 非公開データメンバー
    };

    void foo() {
            A a;
            a.i = 9; // エラー: i は foo() からアクセスできない
    }

    class T {
    	T(const T&); // 非公開コピーコンストラクタ
    };

    void foo( T t ) {}      // エラー: T を渡せない、コピーコンストラクタは非公開
    T f2() { T t; return t; } // エラー: T を返せない

メッセージ ID: inaccessible_w

## 余分な ; 無視します

余分なセミコロンがフィールド宣言の最後に検出されました。この警告メッセージを生成するコードの例:

    struct S {
            int ii;;
            void f();;
    };

メッセージ ID: fieldsemicolonw

## 一時変数のアドレスを取得できません

一時的に作成されたコンパイラのアドレスは取得できません。 この警告メッセージを生成するコードの例を次に示します。

    struct C { C(int); };
    void add( C *c );
    void foo() { add( &C(6) ); }

メッセージ ID: addressoftemp

## フレンド宣言では記憶クラスは使用できません

この警告メッセージを生成するコードの例:

    struct A {
            friend static void foo(A arg);
    };

メッセージ ID: storeclassfriend

## 列挙名〜はスコープ修飾子として使用されました

この警告メッセージを生成するコードの例:

    class C {
                C::C();
                enum E { a, b } e;
    };
    C::C() {
                switch(e) {
                    case E::a:       // <-- ここで失敗                 break;	    } }

メッセージ ID: enumasscope

## 文は到達不可能です

この文は到達しません。 このエラーメッセージを生成するコードの例を次に示します。

    int foo(int x) {
      if ( x > 0 )
    	return 1;
      else
    	return 2;
      return 3;	// 警告: 文は到達不可能
    }

メッセージ ID: wunreachable

## 最後の文は値を返す必要があります

non-void 関数である最後の文は値を返す必要があります。 このエラーメッセージを生成するコードの例を次に示します。

    int foo(int x) {
      if ( x > 0 )
    	bar();  // 警告: 最後の文は値を返す必要がある
    	return 2;
    }

メッセージ ID: wnoretvalue

## else 分岐は値を返す必要があります

if 文である else 分岐は値を返す必要があります このエラーメッセージを生成するコードの例:

    int foo(int x) {
      if ( x > 0 )  // 警告: els 分岐は値を返す必要がある
    	return 2;
    }

メッセージ ID: wnoelseretvalue

## クラス内の無名の構造体は〜にすることはできません

クラス内の無名の構造体は extern、static、およびそれに相当する識別子を持つことはできません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {
        static struct {  // エラー: 無名の構造体は static にはできない
            int a;
            long b;
        };
    };

メッセージ ID: badclanonstruct

## 無名の構造体の名前が同じです

無名の構造体メンバー %1 の名前がそれを含むクラスの名前と同じです このエラーメッセージを生成するコードの例:

    class A {
      struct {
        int i;
        long j;
        int A;  // エラー
      };
    };

メッセージ ID: sameanonstruct

## 無名の構造体は非公開メンバーまたは限定公開メンバーを持つことはできません

無名の構造体は非公開または限定公開メンバーを持つことはできません このエラーメッセージを生成するコードの例:

    static struct {
            long j;

            private:
            	int i; // エラー
    };

メッセージ ID: anonstructnoprivate

## 無名の構造体は関数のメンバーを持つことはできません

無名の構造体は関数のメンバーを持つことはできません。 このエラーメッセージを生成するコードの例を次に示します。

    static struct {
            void foo(){} // エラー
    };

メッセージ ID: anonstructnofunc

## 無名の構造体は宣言されます

この警告メッセージを生成するコードの例:

    union U {
        struct {
            int a;
            long b;
        };
    };

メッセージ ID: anonstruct

## 前方列挙型は宣言されます

この警告メッセージを生成するコードの例:

    enum  A;

メッセージ ID: forwardenum

## 〜 宣言が宣言を使用して導入された〜と衝突します

名前空間スコープ内またはブロックスコープ内での関数の宣言が、`using` 指令によって導入された関数と同じ名前と同じパラメータ型を持つ場合、そのプログラムは不正です。 このエラーメッセージを生成するコードの例を次に示します。

    namespace B {
        void f(int);
    }

    namespace N {
        using B::f;             //  B::f(int) を N に導入
        void f(int);            //  エラー: N::f(int) が衝突
    B::f(int)
    }

メッセージ ID: ambigdecl

## 共用体は参照型のメンバーを含むことができません

共用体が参照型のメンバーを含む場合そのプログラムは不正です。 このエラーメッセージを生成するコードの例を次に示します。

    union x {
        int &i;
    };

メッセージ ID: nounionref

## シフト数が大きすぎます

この警告メッセージを生成するコードの例:

    unsigned long l;
    void foo()
    {
            l >> 32; // 警告を取得
    }

メッセージ ID: largeshift

## 一時変数のアドレスを取得できません

一時的に作成されたコンパイラのアドレスは取得できません。

メッセージ ID: compataddressoftemp

## 整数を使用して列挙型を初期化することはできません

この警告メッセージを生成するコードの例:

    enum E { e1 = 5 };
    struct S { E e; } s = { 5 }; // 警告

メッセージ ID: wintenuminit

## 関数〜は、置き換えられた関数〜により送出された例外のみを送出できます

関数は、置き換えられた関数により許可された例外のみを送出できます。このエラーメッセージを生成するコードの例:

    struct A
    {
            virtual void foo() throw(A);
    };

    struct B : A
    {
            virtual void foo();
    };

メッセージ ID: lessrestrictedthrow

## 〜が〜を隠してます

通常の delete 演算子はスコープには見つかりませんでした。おそらくクラススコープ内で不正に置き換えられたためです。 このエラーメッセージを生成するコードの例を次に示します。

    #include <new>

    template<class t_arg> class A {
        public:
    	void  operator delete(void*, const std::nothrow_t&) throw();
    };

    int main () {
        A<int> * a = new A<int>;
    }

メッセージ ID: whideferr

## 定数指定の関数からのメンバーの不正なアクセス

このエラーメッセージを生成するコードの例:

    class A {
        public:
    	int a;
    	void foo () const { a++; }
    }

メッセージ ID: constaccess

## クラス〜の明示的なインスタンス化宣言が無効です

明示的なインスタンス化宣言にキーワード 'class' が抜けている可能性があります。 このエラーメッセージを生成するコードの例を次に示します。

    template  class X
    {
    };

    template X ;  // template class X ; でなければならない

メッセージ ID: explclassinst

## 一時変数を使用して非定数参照を初期化してはいけません

一時変数を使用して非定数参照を初期化してはいけません この警告メッセージを生成するコードの例:

    struct C { C(int); };
    void add( C& c );
    void foo() { add( C(6) ); }

メッセージ ID: reftotemp

## 式は定数値を含んでいなければなりません

テンプレート式は非定数値であってはいけません。 このエラーメッセージを生成するコードの例を次に示します。

    template <const int& ri> void f();int main()
    {
        const int& ri = 12;
        f<ri>();        // エラー
    }

メッセージ ID: tmplexpnotconst

## 関数〜は、置き換えられた関数〜により送出された例外のみを送出できます

関数〜は、置き換えられた関数〜により許可された例外のみを送出できます。この警告メッセージを生成するコードの例:

    struct A
    {
            virtual void foo() throw(A);
    };

    struct B : A
    {
            virtual void foo();
    };

メッセージ ID: wlessrestrictedthrow

## 自動変数のアドレスを返しています

ローカル自動変数へのポインタを返しています。 この警告メッセージを生成するコードの例:

    int* f() {
      int k=5;
      return &k;
    }

メッセージ ID: autoaddrreturn

## パラメータの型のポインタがサイズのわからない配列を指しています

サイズのわからないパラメータの配列を指しています。このエラーメッセージを生成するコードの例:

    typedef int UNKA[];
    void f(UNKA *p);

メッセージ ID: ptrarray0

## パラメータの型の参照先はサイズのわからない配列です

サイズのわからないパラメータの配列を参照しています。このエラーメッセージを生成するコードの例:

    typedef int UNKA[];
    void f(UNKA &p);

メッセージ ID: refarray0

## 実引数は使用箇所が推測できないテンプレートパラメータに依存しています

実引数はテンプレートパラメータに依存します。このエラーメッセージを生成するコードの例:

    void foo(...);
    template <class T> T count(T t);void bar() {
      foo(count);
    }

メッセージ ID: dummyactualarg

## 識別子が予期される位置に〜があります

識別子を必要としていました。構造がエラー状態のままで使用されますが、コンパイラが効果的に回復します。 このエラーメッセージを生成するコードの例を次に示します。

    enum A {a, };

メッセージ ID: identexpected

## 〜および〜に同名の extern 名〜があります

2 つの関数定義が同じ extern 名を持つことはできません。このエラーメッセージを生成するコードの例:

    #pragma redefine_extname        fstat64 fstat

    extern "C"
    {
    int fstat(int fstat_int)
    {
            return (fstat_int+2);
    }
    int fstat64(long fstat64_long)
    {
            if (fstat64_long == 0)
                    return 0;
            return -1;
    }
    }  // エラー, fstat64 が fstat と同じ extern 名

メッセージ ID: sameextname

## 局所型の static 変数ブロックには互換モードでの全プログラムの最適化を使用できません

互換モードで全プログラムの最適化 (-xcrossfile または -xipo) のコンパイルを行う場合は、static 変数を内部スコープに入れ子にすることはできません。

例

    int f(int i)
    {
    	if (i != 0) {
    		static int sv = 2;
    		return sv + i;
    	}
    	return 0;
    }

static 変数がこのエラーメッセージを生成します。

メッセージ ID: nocrossstatic

## 静的なデータメンバー定義は派生クラスを使用します

静的なデータメンバー定義は派生クラスを使用します。この警告を生成するコードの例を次に示します。

    struct BASE { static int static_data; };
    struct DERIVED : public BASE { };
    int DERIVED::static_data;

メッセージ ID: staticmemsearch

## クラステンプレートでフィールド宣言の解析に失敗。フィールドを読み飛ばします

フィールド宣言は、おそらく名前検索に問題があるためにテンプレートクラスの典型的なインスタンス化において解析を行うことができません。このテンプレートクラスは無効となります。

例:

    template < class T>
    struct base
    {
      typedef T b_type ;
    } ;

    template < class T>
     struct derived : public base < T*>
    {
      typedef base < T*> Base ;
      const b_type foo ( const T & t ) const { }
    } ;

メンバー関数 foo は、派生クラスに関する典型的なインスタンス化を解析するときに b_type を型として検出できないため、解析できません。

メッセージ ID: skipfield

## 例外指定は typedef 中では使用できません

typedef 宣言では、例外指定を使用することはできません。

例:

    typedef void (*pf) () throw();

メッセージ ID: badexceptionspec

## 関数ポインタは関数ポインタの割り当てを通してのみ例外を送出できます

関数ポインタは、割り当てられる関数ポインタを通してのみ例外を送出できます。この警告を生成するコードの例を次に示します。

    void (*pf1)();
    void (*pf2)() throw(int);
    void f() {
        pf2 = pf1;
    }

メッセージ ID: fptrthrow

## nowait、if、ordered、default、または schedule 節を 1 つだけ pragma に指定できます

このメッセージを生成するコードの例を次に示します。 int NE_C2_3() { int a = 1;

    #pragma omp parallel if ( a> 1 ) if ( a < 5 )     {     }          return 0; }

メッセージ ID: omp_extraclause

## return、goto、break、または continue 文は openmp 構造体ブロックでは使用できません

OpenMP 並列構造とワークシェアリング構造には、そのあとに構造体ブロックが続くことが必要とされています。構造体ブロックは、1 つの入り口と 1 つの出口をもつ文です。構造体ブロックに入ったり、構造体ブロックから出たりする文を使用することはできません。つまり、構造体ブロックには、制御をブロックから別の場所に移すような return、goto、break、または continue などの文は使用できません。 このメッセージを生成するコードの例を次に示します。

    int NE_C2_4_1_1()
    {
    int i;
    #pragma omp for
        for (i = 0 ; i < 10 ; i++ )      { 	break ;     }     return 0; }

メッセージ ID: omp_structblkviolation

## omp for ループのインデックスの値は正の整数でなければなりません

OpenMP for ループのインデックス変数の値は符号付き整数型である必要があります。このメッセージを生成するコードの例を次に示します。

    int NE_C2_4_1_3()
    {
    unsigned int i;
    #pragma omp for
        for (i = 0 ; i < 10 ; i++ )      {     }     return 0; }

メッセージ ID: omp_forbadindxtype

## section 指令は sections 指令の構文範囲外には指定できません

"section" OpenMP pragma は "sections" ブロックのすぐ内側に配置する必要があります。 このメッセージを生成するコードの例を次に示します。

    int NE_C2_4_2_1()
    {
    #pragma omp sections
        {
    	;
        }
    #pragma omp section
        {
        }
        return 0;
    }

メッセージ ID: omp_sectionoutsidesections

## flush 指令中の変数指定に参照型があってはなりません

このメッセージを生成するコードの例を次に示します。

    int NE_C2_6_5_1()
    {
        int i = 5;
        int & n = i;
    #pragma omp parallel
        {
    #pragma omp flush (n)
        }
        return 0;
    }

メッセージ ID: omp_varhasreftype

## 順序づけられた指令が順序づけられていない指令の構文範囲内で使用されています

順序づけられた OpenMP 指令は、順序づけられた節が指定されていない for 指令の動的範囲内にあってはなりません。 このメッセージを生成するコードの例を次に示します。

    int NE_C2_6_6_1()
    {
    int i;
    #pragma omp for
        for (i=0; i<10 ; i++)     { #pragma omp ordered 	{ 	}     }     return 0; }

メッセージ ID: omp_nonorderedfor

## threadprivate 指令はファイルスコープになければなりません

threadprivate 指令はファイルスコープまたはネームスペーススコープになければならず、かつどのような定義または宣言よりも外側になければなりません。 このメッセージを生成するコードの例を次に示します。

    int a=0;

    class A
    {
    #pragma omp threadprivate ( a )
    };

    int NE_C2_7_1_1b()
    {
        return a;
    }

メッセージ ID: omp_nonfilethreadprivate

## threadprivate 指令は変数へのすべての参照の前になければなりません

threadprivate 指令は、そのリスト内の変数へのすべての参照よりも (構文的に) 前に存在する必要があります。 このメッセージを生成するコードの例を次に示します。

    int a = 1;

    void foo()
    {
        a--;
    }

    #pragma omp threadprivate ( a )

    int NE_C2_7_1_1c()
    {
        return a;
    }

メッセージ ID: omp_threadprivateprecederef

## 変数は参照型であってはなりません

threadprivate 変数は参照型であってはなりません。 このメッセージを生成するコードの例を次に示します。

    int a;
    int & b = a;

    #pragma omp threadprivate (b)

    int NE_C2_7_1_6a()
    {
        return 0;
    }

メッセージ ID: omp_varinprivateref

## 変数は不完全な型をもってはいけません

このメッセージを生成するコードの例を次に示します。

    class A;

    int foo(A & a)
    {
    #pragma omp parallel private (a)
        {
        }
        return 0;
    }

    int NE_C2_7_2_1_3()
    {
        return 0;
    }

メッセージ ID: omp_varinprivateincomplete

## threadprivate 変数はこの節では使用できません

threadprivate 変数は、copyin 節、schedule 節、または if 節以外の節に指定することはできません。このため、この変数を、private、firstprivate、lastprivate、shared、または reduction などの節では使用できません。これらはデフォルトの節には影響されません。 このメッセージを生成するコードの例を次に示します。

    int a;

    #pragma omp threadprivate( a )

    int NE_C2_7_1_4a()
    {
    #pragma omp parallel private (a)
        {
        }
        return 0;
    }

メッセージ ID: omp_threadprivatewrongclause

## 節中で指定された変数は定数指定の型をもっていてはいけません

mutable メンバーをもつクラス型でないかぎり、private 節で指定された変数は定数指定の型をもつことはできません。 このメッセージを生成するコードの例を次に示します。

    class A
    {
    public:
        A();
    };

    int NE_C2_7_2_1_2()
    {
        const A a;
    #pragma omp parallel private(a)
        {
        }

        return 0;
    }

メッセージ ID: omp_varmustnotbeconstqual

## 変数は omp pragma のデータ属性節に明示的にリストされなければなりません

このメッセージを生成するコードの例を次に示します。

    int NE_C2_7_2_5_2()
    {
        int a;
    #pragma omp parallel default (none)
        {
    	a=1;
        }
        return 0;
    }

メッセージ ID: omp_defaultviolated

## 縮約変数の型が無効です

縮約節に指定される変数の型は、ポインタの型が使えない場合を除き、縮約演算子に対して有効でなければなりません。 このメッセージを生成するコードの例を次に示します。

    class A
    {
    };

    int NE_C2_7_2_6_1a()
    {
        A a;
    #pragma omp parallel reduction(+:a)
        {
        }
        return 0;
    }

メッセージ ID: omp_reductionbadtype

## 縮約変数は定数指定の型をもっていてはいけません

縮約節に指定される変数は定数指定の型をもつことはできません。 このメッセージを生成するコードの例を次に示します。

    int NE_C2_7_2_6_2()
    {
        const int a = 0;
    #pragma omp parallel reduction (+: a)
        {
        }
        return 0;
    }

メッセージ ID: omp_constreduction

## 変数は複数の節に指定してはいけません

変数を 2 つ以上の節に指定することはできません。ただし、firstprivate 節と lastprivate 節の両方に指定することはできます。 このメッセージを生成するコードの例を次に示します。

    int NE_C2_7_2_6_4()
    {
        int a = 0;
    #pragma omp parallel  shared (a) reduction (+: a)
        {
        }

        return 0;
    }

メッセージ ID: omp_dupclause

## copyin 変数は threadprivate ではありません

copyin 節に指定する変数は、threadprivate 変数でなければなりません。 このメッセージを生成するコードの例を次に示します。

    int x;

    int NE_C2_7_2_7_2()
    {
    #pragma omp parallel copyin (x)
        {
        }
        return 0;
    }

メッセージ ID: omp_copyinnotthreadprivate

## 同じ名前の critical 指令はそれぞれ入れ子にすることはできません

同じ名前の critical 指令は、お互いの中で入れ子にすることができません。 このメッセージを生成するコードの例を次に示します。

    int NE_C2_9_3_1()
    {
    #pragma omp critical
        {
    #pragma omp critical
    	{
    	}
        }
        return 0;
    }

メッセージ ID: omp_badnestingcritical

## 指令は領域の動的範囲中では利用できません

for、sections、および single 指令は、critical、ordered、および master 領域の動的範囲内では使用できません。 このメッセージを生成するコードの例を次に示します。

    int NE_C2_9_4_4()
    {
    #pragma omp master
        {
    #pragma omp for
    	for ( int i=0 ; i < 10 ; i++ ) 	{ 	}     }     return 0; }

メッセージ ID: omp_badnestingregion

## 同じ並列にバインドされた for, sections, single 指令は、それぞれの入れ子のなかでは使用することができません

同じ並列にバインドされた for, sections, single 指令は、それぞれの入れ子のなかでは使用することができません。 このメッセージを生成するコードの例を次に示します。

    int NE_C2_9_2_1()
    {
    #pragma omp parallel
        { int i;
    #pragma omp for
    	for (i=0 ; i < 10 ; i++)  	{   #pragma omp sections  	    { 		;	    }  	}     } 	     return 0; }

メッセージ ID: omp_badnestingparallel

## flush 指令を含む最小の文はブロックでなくてはなりません

flush 指令を含む最小の文はブロック (または複合文) でなくてはなりません。 このメッセージを生成するコードの例を次に示します。

    int NE_C2_6_5_2()
    {
        int i = 5;
    #pragma omp parallel
        {
    	if ( i> 0 )
    #pragma omp barrier
        }
        return 0;
    }

メッセージ ID: omp_mustbeblock

## schedule(runtime) が指定されている場合、chunk_size を指定してはなりません

schedule(runtime) が指定されている場合、chunk_size を指定してはなりません。 このメッセージを生成するコードの例を次に示します。

    int NE_C2_4_1_9()
    {
        int i;
    #pragma omp for schedule(runtime, 2)
        for (i=1;i<10;i++)     {     }     return 0; }

メッセージ ID: omp_chunksizemustnotbespecified

## 節は指令の中では使用できません

このメッセージを生成するコードの例を次に示します。

    int main(void)
    {
    #pragma omp for default(none)
        for (int i = 0 ; i < 10 ; i++ )      {     }     return 0; }

メッセージ ID: omp_badclause

## 現プラグマの残りを新しい行まで読み飛ばします

現プラグマの残りを新しい行まで読み飛ばします。 これは、OpenMP 関連のエラー回復を C++ 固有のエラー回復と分離するために使用されます。 このメッセージを生成するコードの例を次に示します。

    int main(void)
    {
    #pragma omp for default(none)
        for (int i = 0 ; i < 10 ; i++ )      {     }     return 0; }

メッセージ ID: omp_skip

## line 指令は正でなければなりません

line 指令は正の整数を指定しなければなりません。 このエラーメッセージを生成するコードの例を次に示します。

    #line 0 "file.cc"

メッセージ ID: poslinenum

## 変数は openmp プラグマに囲まれた中で非公開として指定されています

並列領域内で非公開 (firstprivate/lastprivate) である変数は、囲まれたワークシェアリング指令または並列指令での private (firstprivate/lastprivate) 節に指定することはできません。このため、ワークシェアリング指令または並列指令で非公開として指定されている変数は、囲まれた並列領域内で共有する必要があります。 このメッセージを生成するコードの例を次に示します。

    int main()
    {
        int i,j;
        #pragma omp parallel private(j)
        {
    	#pragma omp for lastprivate(j)
    	for (i=0; i<10; i++) 	    j++;     }     return 0; }

メッセージ ID: omp_varalreadyprivate

## プラグマは入れ子にすることができません

このメッセージを生成するコードの例を次に示します。

    int NE_C2_9_2_1()
    {
    #pragma omp parallel
        { int i;
    #pragma omp for
          for (i=0 ; i < 10 ; i++)       { #pragma omp sections           {               ;           }       }     }      return 0; }

メッセージ ID: omp_badnesting

## 縮約変数が共有されていません

縮約節に指定される変数は、囲んでいるコンテキスト内で共有される必要があります。 このメッセージを生成するコードの例を次に示します。

    int main()
    {
      int i;
      #pragma omp parallel private(i)
    	#pragma omp sections reduction(+:i)
    	{
    	   i++;
    	}
      return 0;
    }

メッセージ ID: omp_reductionnotshared

## OpenMP プラグマの形式が正しくありません

このメッセージは、OpenMP プラグマで一般構文エラーが検出されると表示されます。 このメッセージを生成するコードの例を次に示します。

    int main()
    {
      #pragma omp parallel private
      {
      }
      return 0;
    }

メッセージ ID: omp_badlyformedomppragma

## omp の for ループの制御式は標準の形式をもっていません

OpenMP の for ループの制御式は、以下の標準の形式でなくてはなりません:

    int main()
    {
        int i,j=0;
        #pragma omp parallel for
        for (i=0; j<10; i++) {     }     return 0; }

メッセージ ID: omp_forbadcontrol

## デフォルトの節の値が不正です

デフォルトの節に使用できる値は none または shared のみです。 このメッセージを生成するコードの例を次に示します。

    int main()
    {
      int i;
      #pragma omp parallel default(private)
      {
    	i++;
      }
      return 0;
    }

メッセージ ID: omp_baddefault

## schedule 節に対する無効な種別

schedule 節の種別は、static、dynamic、guided、runtime のうちのいずれかでなければなりません。 このメッセージを生成するコードの例を次に示します。

    int main()
    {
      int i;
    #pragma omp parallel for schedule(normal,1)
      for (i=0;i<10;i++) {   }   return 0; }

メッセージ ID: omp_badschedulekind

## 無効な OpenMP プラグマ

このメッセージを生成するコードの例を次に示します。

    int main()
    {
    #pragma omp unknown
        return 0;
    }

メッセージ ID: omp_badomppragma

## openmp 構造体ブロックへの出入りに return、goto、break、または continue 文を使うことはできません

OpenMP 並列構造とワークシェアリング構造には、そのあとに構造体ブロックが続くことが必要とされています。構造体ブロックは、1 つの入り口と 1 つの出口をもつ文です。構造体ブロックに入ったり、構造体ブロックから出たりする文を使用することはできません。つまり、構造体ブロックには、制御をブロックから別の場所に移すような return、goto、break、または continue などの文は使用できません。 このメッセージを生成するコードの例を次に示します。

    int foo() {
        #pragma omp parallel
        {
    	return 1;
        }
    }

メッセージ ID: omp_strblkviolation

## omp の for ループの反復式は標準の形式をもっていません

OpneMP の for ループの反復式は標準の形式をもっている必要があります。 このメッセージを生成するコードの例を次に示します。

    int main() {
        int i;
        #pragma omp parallel for
        for (i=0; i<10; foo(&i)) {     }     return 0; }

メッセージ ID: omp_forbaditer

## omp の for ループの初期値式は標準の形式をもっていません

OpenMP の for ループの初期値式は以下のような標準の形式をもっていなければなりません。 = or = このメッセージを生成するコードの例を次に示します。

    int main() {
        int i=0;
        #pragma omp parallel for
        for (; i<10; i++) {     }     return 0; }

メッセージ ID: omp_forbadinit

## プラグマ用に OpenMP の後には for 文がなければなりません

OpenMP の後に、プラグマ用に for 文を使用する必要があります。 このメッセージを生成するコードの例を次に示します。

    int main() {
        int i=0;
        #pragma omp parallel for
        {
        while( 0 ){
    	i++;
        }
        return 0;
    }

メッセージ ID: omp_forbadfollow

## \"%1\" の宣言は関数です。オブジェクトではありません

\"%1\" の宣言は構文上あいまいです。標準では関数の宣言と解釈されます。 これに対し、プログラマはオブジェクトの宣言を意図している場合がよくあります。 混同を避けるため、構文上明確な方法で宣言し直してください。 この警告メッセージを生成するコードの例を次に示します。

    struct T { };
    T t( T() ); // t は関数

構文上明確な、推奨される代替の記述は次のとおりです。

    T t( (T()) ); // t はオブジェクト (型に余分な括弧は記述できない)
    T t = T(); // t はオブジェクト (代入による初期化)
    T t( T(*)() ); // t は関数 (明示的関数ポインタ)

メッセージ ID: ambigfuncdecl

## schedule 節の繰り返し数の式が不正です

chunksize はループの不変値で、ゼロでない正の整数である必要があります。 このエラーメッセージを生成するコードの例を次に示します。

    #pragma omp for schedule (static, 0)

メッセージ ID: badchunksize

## 並列領域内のループのインデックスは、非公開変数でなければなりません

並列領域内のループのインデックスは、その領域の非公開変数でなければなりません。 このメッセージを生成するコードの例を次に示します。

    int main() {
         int i=0;
         #pragma omp parallel for shared(i)
             for(i=0; i<4; i++){          }      return 0; }

メッセージ ID: omp_sharedforindex

## クラスが空の仮想基底クラスとして出現しています

このファイルで使用されているクラスには、非静的データメンバーを含まない仮想基底クラスが含まれます。ある条件下では、仮想関数呼び出しで誤った関数が呼び出される可能性があります。

メッセージ ID: warn_empty_virt_base

## 参照が返す値は左辺値でなければなりません (この関数の値を使用した場合、結果は予期できません)

参照する戻り値は左辺値でなければなりません。標準では、関数が右辺値 への参照を戻すように記述することもできます。が、実際にこの値を使用した場合、その結果は予期できません。）

メッセージ ID: nonvarrefww

## 純粋仮想関数の呼び出しは常に失敗します

まだ関数がオーバーライドされていないオブジェクトから純粋仮想関数を呼び出そうとすると、必ず失敗します。 基底クラスの純粋仮想関数は、仮想呼び出しメカニズムを介して呼び出されることはありません。その呼び出しを明示的に指定したうえで、別の関数定義内で関数本体を記述する必要があります。 次のような例になります。

    struct T {
        virtual int f() = 0;
        T() { f(); }         // 警告: 純粋仮想関数の呼び出し
        T() { T::f(); }      // OK: 仮想呼び出しメカニズムを経由
        void g() { f(); }    // OK: g() が派生クラスのオブジェクトから呼び出された場合
    };
    int T::f() { return 0; } // 純粋仮想関数の定義

メッセージ ID: pure_virtual_w

## プラグマ critical は同名の critical 内では入れ子にすることができません

同じ名前の critical 指令は、お互いの中で入れ子にすることができません。 このメッセージを生成するコードの例を次に示します。

    void main(void) {
        #pragma omp critical(foo)
            #pragma omp critical(foo)
            ;
    }

メッセージ ID: omp_badcriticalnesting

## メソッドは前もって native と宣言されていません

ネイティブと宣言された Java メソッドは、C++ 関数を使用して実装する必要があります。前もって .class ファイルでネイティブメソッドと宣言されていない場合は、メソッドの C++ バージョンを指定するとエラーになります。

メッセージ ID: notjavanative

## 非 POD オブジェクトが可変引数として関数に渡されました

可変引数として非 POD オブジェクトを渡した場合の結果は不確定です。

POD (Plain Old Data) オブジェクトとは、ユーザー宣言のコンストラクタ、ユーザー定義のデストラクタ、ユーザー定義のコピー代入演算子、基底クラス、仮想関数、静的でない非公開または限定公開データメンバー、およびメンバーへのポインタ、非 POD 構造体、非 POD 共用体、または参照型の静的でないデータメンバーをもたないオブジェクトです。

    void foo(int, ...);
    struct T {
        T();
        ~T();
    };

    extern T t;

    int main()
    {
        foo(1, t); // 警告
    }

メッセージ ID: nonpodvarargw

## friend 宣言はクラスまたは関数を指定しなければなりません

friend 宣言にクラス、関数とも指定されていません。 このエラーメッセージを生成するコードの例を次に示します。

    namespace N {
    	template  struct B { };
    }
    struct A {
      friend struct N::B; // ここでエラーが発生する。B は構造体ではなくテンプレート
    };

メッセージ ID: wnofriendfield

## フレンド宣言は構文に <> を追加しなければならない可能性があります

フレンド宣言は、非テンプレート関数を宣言しています。 この警告を生成するコードの例を次に示します。

    template < class T> bool foo (T);
    template < class T1> class BC_base_identifier {
            friend bool foo(T1);
    };
    int main()
    {
            BC_base_identifier bi;
            foo(100);
    }

メッセージ ID: nontmplfriend

## #pragma dumpmacros の呼び出しに不正な引数が渡されました

#pragma dumpmacros に対する有効な引数は、defs、undefs、loc、conds、および sys です。 このエラーメッセージを生成するコードの例を次に示します。

    #pragma dumpmacros(definitions)

メッセージ ID: prbadarg

## 深さが入れ子になっているテンプレートが非テンプレート関数とともに使用されていません

深さが入れ子になっているテンプレートで関数テンプレートの特殊化が指定されていますが、使用できるのは非テンプレート関数だけです。 このエラーメッセージを生成するコードの例を次に示します。

    template struct A {
        void f(int);
    };

    template<> template <> void A::f(int) {} // 仕様範囲外

メッセージ ID: mismatchtmpdepth

## 64 ビット型の値の変換

64 ビットへの移植の際に、代入、初期化、またはキャストによってデータが切り捨てられることがあります。 このエラーメッセージを生成するコードの例を次に示します。

    long l;
    (int)l;

メッセージ ID: truncwarn1

## 64 ビットへの符号拡張

64 ビットへの移植の際に、unsigned long に代入される前にデータの符号が拡張される可能性があります このエラーメッセージを生成するコードの例を次に示します。

    int i;
    unsigned long ul = i;

メッセージ ID: signextwarn

## 64 ビット型のビットフィールドが変化する可能性があります

64 ビットへの移植の際に、long または unsigned long ビットフィールド宣言がビットフィールドパッキングを変化させる可能性があります。 このエラーメッセージを生成するコードの例を次に示します。

    struct S {
            unsigned long b1:20;
            long b2:20;

    };

メッセージ ID: bitfield64

## キーワードが定義されています

キーワードが定義されています。 この警告を生成するコードの例を次に示します。

    #define bool unsigned int

メッセージ ID: nokeyworddefine

## あいまいな型変換

2 つ目と 3 つ目のオペランドが互いの型に変換される可能性があります。

    struct S {
        S (int);
        operator int () const;
    };

    int main (int i)
    {
        S s0(0);
        i ? s0 : 1; // あいまいな型変換
    }

メッセージ ID: questambigerr

## threadprivate 指令で指定されたブロックスコープ変数は静的でなければなりません

threadprivate 指令に指定されたブロックスコープ変数は静的でなければなりません。 このメッセージを生成するコードの例を次に示します。

    int main() {
        #pragma omp parallel
        {
            int i;
            #pragma omp threadprivate(i)
            i = 50;
        }
    }

メッセージ ID: omp_threadprivatenotstatic

## threadprivate 指令は、変数のスコープ内に存在しなければりません

静的なブロックスコープ変数の threadprivate 指令は、入れ子になったスコープではなく変数のスコープ内に存在する必要があります。 このメッセージを生成するコードの例を次に示します。

    int main() {
        static int i;
        #pragma omp parallel
        {
            #pragma omp threadprivate(i)
            i = 50;
        }
    }

メッセージ ID: omp_threadprivateinnested

## if 節の式がスカラー型ではありません

OpenMP parallel の if 節に指定された式は、スカラー型である必要があります。 このメッセージを生成するコードの例を次に示します。

    int main() {
        struct { float val; } good = {3.62};

        #pragma omp parallel if(good)
          good.val = 4.12;
    }

メッセージ ID: omp_badiftype

## num_threads 節の式が整数型ではありません

OpenMP parallel の num_threads 節に指定された式は、整数型である必要があります。 このメッセージを生成するコードの例を次に示します。

    int main() {
        int i = 0;

        #pragma omp parallel num_threads(3.62)
            i++;
    }

メッセージ ID: omp_badnumthreadstype

## 完全なクラス定義はテンプレート引数の宣言中では許可されません

テンプレート引数の宣言ではクラス定義は指定できません。 このエラーメッセージを生成するコードの例を次に示します。

    template  class S{};

メッセージ ID: noclassdef

## copyprivate 節は nowait 節とともに使用してはなりません

copyprivate 節は nowait 節とともに使用してはなりません。 このメッセージを生成するコードの例を次に示します。

    int main() {
        int i = 42;
        #pragma omp single nowait copyprivate(i)
        {
          i++;
        }
    }

メッセージ ID: omp_badusecopyprivate

## copyprivate 節で指定された変数は、1 つの閉じたコンテキスト内において非公開でなければなりません

copyprivate 節をもつ単一の指令が並列領域の動的範囲内で検出される場合、copyprivate 節内に指定された変数はすべてこの閉じたコンテキストにおいて非公開でなければなりません。 このメッセージを生成するコードの例を次に示します。

    int main() {
        int i = 1;
        #pragma omp parallel
        {
        i = 42;
          #pragma omp single copyprivate(i)
          {
                i++;
          }
        }
    }

メッセージ ID: omp_notprivateincontext

## const 修飾子には宣言子と初期設定子を指定しなければなりません

const 変数は、宣言子と初期設定子を使用して宣言する必要があります。 このメッセージを生成するコードの例を次に示します。

    const enum E1 {a, b};		// エラー
    const enum E2 {c, d} x = c;	// ok

メッセージ ID: badconstdecl

## volatile 修飾子には宣言子を指定しなければなりません

volatile 変数は宣言子を使用して宣言する必要があります。 このメッセージを生成するコードの例を次に示します。

    volatile enum E1 {a, b};		// エラー
    volatile enum E2 {c, d} x;		// ok

メッセージ ID: badvoldecl

## 記憶クラス指定子には宣言子を指定しなければなりません

記憶クラス指定子に初期宣言子リストが必要です。 このメッセージを生成するコードの例を次に示します。

    register enum E4 { a4, b4 };	// エラー
    register enum E5 { a5, b5 } e;  // これは ok

メッセージ ID: badstgdecl

## 宣言中に宣言子が必要です

このタイプの宣言では初期宣言子リストが必要です。 このメッセージを生成するコードの例を次に示します。

    typedef struct T { int i; };
    typedef enum F { f1, f2 };

メッセージ ID: declreq

## 記憶クラスはフレンド宣言中では許可されません

このエラーメッセージを生成するコードの例:

    struct A {
            friend static void foo(A arg);
    };

メッセージ ID: storefrienderr

## 異なる enum 型を比較しています

この警告メッセージを生成するコードの例:

    #include

    int main()
    {
            enum Shape { shape1=2, shape2};
            enum Point { point1=4, point2};

            Shape cylinder = shape1;
            Point uper = point2;
            if ( cylinder == uper ) // 警告
                    cout << "Comparing different enum types" << endl; }

メッセージ ID: diffenumtype

## [ヒント: -xarch=v8plus を付けてコンパイルしたオブジェクトは -xarch=v8plus オプションを付けてリンクしなければなりません]

メッセージ ID: demxarchv8plus

## デフォルトの引数式を生成する際に無限の再帰が発生しました

このメッセージを生成する例を次に示します。

    struct S {
    		int f1(int = f2());
    		int f2(int = f1());
    	};

メッセージ ID: recurseindefault

## キーワード \"virtual\" と \"friend\" は同一宣言内には指定できません

仮想関数はフレンド関数として宣言することはできません。 このエラーメッセージを生成するコードの例を次に示します。

    void foo() { return; }
    void goo() { return; }

    class A {
            virtual friend void foo();    // エラー
            virtual friend void A::goo(); // エラー
    };

メッセージ ID: virtfriendfunction

## 関数 \"%1\" は、不完全な関数宣言構文を使用して \"friend\" と宣言されました

フレンド関数が関数名だけで宣言されました。 このエラーメッセージを生成するコードの例を次に示します。

    namespace N {
      void foo(char);
      void foo();
    };

    class A {
      friend N::foo;
    };

メッセージ ID: friendfunc

## 暗黙の符号なしビットフィールドに負の値を代入しています

この警告メッセージを生成するコードの例:

    struct No_constructor {
            int i : 30;
    };

    class Has_constructor {
            int j : 30;
    public:
            Has_constructor():j(-2){}       // 8 行目: 警告
    };

    int main() {
            struct No_constructor b = {1-2};// 12 行目: 警告
            b.i = -1.8;                     // 13 行目: 警告
    }

メッセージ ID: negbitfield

## オブジェクトまたは関数の名前は、テンプレート ID にすることはできません

この警告メッセージを生成するコードの例:

    namespace N {
        template struct ap {
            ap(X* p = 0);
        };
    };
    using namespace N;
    class A { };
    A* a;
    ap ap(a) ;

メッセージ ID: baddeclare

## OpenMP private、firstprivate、または lastprivate データ節でクラスオブジェクトを使用する場合は、クラスがデフォルトコンストラクタをもっていなければなりません

この警告メッセージを生成するコードの例を次に示します。

    class A {

    };
    main()
    {
        A a(10);
        #pragma omp parallel private(a)
        {
            ;
        }
    }

メッセージ ID: nodefctor

## テンプレートの明示的な特殊化の宣言、または明示的な特殊化の定義を目的としたと思われる構文が生成されましたが、この構文はあいまいであり無効です。ほかのコンパイラでは、このコードの解釈が異なる可能性があります

この警告を生成するコードの例を次に示します。

    template  class A { ... };
    class A; // 警告: 無視されます
    template<> class A; // 明示的な特殊化の宣言
    template   class A; // 明示的なインスタンス化指令

メッセージ ID: oldspecialdecl

## 関数はデータではないため、__thread 指定子を指定することはできません

この警告を生成するコードの例を次に示します。

    __thread void func();
    struct type {
        __thread void func();
    };

メッセージ ID: nothreadfuncs

## __thread 変数の最初の宣言ではそのように指定する必要があります

この警告を生成するコードの例を次に示します。

    int changed;
    __thread int changed;

メッセージ ID: threaddeclfirst

## 動的初期設定子は __thread 変数ではサポートされません

__thread 変数では動的初期設定子はサポートされません。 動的な初期設定子は、自明ではない コンストラクタ、デストラクタ、基底クラス、または定数でない初期設定子の式で指定できます。 この警告を生成するコードの例を次に示します。

    struct nontrivial_constructor {
        nontrivial_constructor();
    };
    __thread nontrivial_constructor unsupported1;
    struct nontrivial_destructor {
        nontrivial_destructor();
    };
    __thread nontrivial_destructor unsupported2;
    struct nontrivial_base : nontrivial_constructor {
    };
    __thread nontrivial_base unsupported3;
    extern int func();
    __thread int unsupported4 = func();

メッセージ ID: threaddyninit

## 自動変数を __thread 変数にすることはできません

この警告を生成するコードの例を次に示します。

    void func() {
        __thread int a;
    }

メッセージ ID: noautothread

## テンプレートの明示的な特殊化内で型名を使用することはできません

この警告を生成するコードの例を次に示します。

    template struct traits {
        typedef T ty;
    };

    template struct tn {
        typedef typename traits::ty tn_ty;
    };

    template <> struct tn {
        typedef typename traits::ty tn_ty;
    };

メッセージ ID: explctspectypename

## クラス内の非公開メンバーに対してアクセスが試みられました

この警告を生成するコードの例を次に示します。

    class A {
            private:
                    int a;
    } ;
    struct B: A {
            private:
            A::a;	// 標準モードでの警告
    } ;

メッセージ ID: inaccessible_anach

## 非公開変数はその節には指定できません

並列領域内で非公開である変数は、並列構文にバインドされた、分業指令上の reduction 節内に指定することはできません。 このメッセージを生成するコードの例を次に示します。

    int main() {
        int i;
        #pragma omp parallel private(i)
        #pragma omp sections reduction(+:i)
        {
            i++;
        }
    }

メッセージ ID: omp_cant_be_in_private

## 縮約変数はこの節には指定できません

並列指令の reduction 節に現れる変数は、並列構文にバインドされた、分業指令上の reduction 節内に指定することはできません。 このメッセージを生成するコードの例を次に示します。

    int main() {
        int i;
        #pragma omp parallel reduction(+:i)
        #pragma omp sections reduction(+:i)
        {
    	i++;
        }
    }

メッセージ ID: omp_cant_be_in_reduction

## 節で指定された変数は、const 修飾された型であってはなりません

mutable メンバーをもつクラス型でないかぎり、private 節で指定された変数は const 修飾された型であってはなりません。 このメッセージを生成するコードの例を次に示します。

    class A
    {
    public:
        A();
    };

    int NE_C2_7_2_1_2()
    {
        const A a;
    #pragma omp parallel private(a)
        {
        }

        return 0;
    }

メッセージ ID: omp_varmustnotbeconst_qual

## 各 OpenMP セクションは、構造化ブロックでなければなりません

1 つのセクションに複数の文が含まれる場合は、それらを {} 内に配置する必要があります。 このメッセージを生成するコードを示します。

    #pragma omp sections
    {
    // 任意の #pragma omp セクション
      x = 5;
      y = 10;
    }

メッセージ ID: omp_badsectionstructure

## フレンド関数のテンプレート ID 名はテンプレート宣言を示すものでなければなりません

フレンド関数名がもっとも近い名前空間で宣言されているテンプレートを使用していないか、あるいは現在のクラス内で宣言されているものを使用しています。 このエラーメッセージを生成するコードの例を次に示します。

    #include
    namespace M {
      template < class T> void i(T);
      class A {
        template < class T> void i(T);
        friend void i<> ( int );       // フォームが不正 - A::i
      };
      template< typename T>
      class Bar
      {
        std::valarray
     fVA ;
        friend std::valarray
     const
        Fu<>( Bar
     const & ) ;     // Fu<> は名前空間 M 内に宣言をもたない
      } ;
    };

メッセージ ID: wnotempdecl

## 外部リンケージはインライン関数には使用できません

外部リンケージはインライン関数には使用できません。 このメッセージを生成するコードの例を次に示します。

    int f();
    inline int f() { return 0; }

メッセージ ID: wbadlinkage_w

## 外部シンボルだけがリンカースコープを持つことができます

この警告を生成するコードの例を次に示します。

    static __symbolic int variable;
    static __hidden int function() {
         __global int stackvar;
    }

メッセージ ID: ldscopeonlyextern

## リンカースコープは、より制限される方向にのみ指定可能です

リンカースコープの制限は後続の宣言では強化することしかできません。 制限がもっとも強いのはリンカースコープ __hidden であり、__symbolic、__global、特に指定のないリンカースコープの順となります。 この警告を生成するコードの例を次に示します。

    __hidden int function();
    __symbolic int function();

メッセージ ID: ldscoperestrict

## リンカースコープはシンボル定義のあとでは変更できません

この警告を生成するコードの例を次に示します。

    __symbolic int function() { }
    __hidden int function();

メッセージ ID: ldscopechanged

## \"%1\" の値から \"%2\" への変換では切り捨てが発生します

この警告を生成するコードの例を次に示します。

    char c[100000];
    short i = sizeof(c);

メッセージ ID: truncwarn2

## 参照メンバーをもつクラスには、ユーザー定義のコンストラクタが存在しなければなりません

参照メンバーをもつクラスは、ユーザー定義のコンストラクタが存在しなければなりません。 このエラーメッセージを生成するコードの例を次に示します。

    struct S {
        int x&;

    };

    メッセージ ID: refmemnoconstr

## 使用されている pch ファイルに正しいマジック番号が存在しません

使用されている pch ファイルに正しいマジック番号が存在しません。

メッセージ ID: pchbadmagicnumber

## 使用されている pch ファイルのフロントに、不正なフォーマット文字列が存在します

使用されている pch ファイルのフロントに、不正なフォーマット文字列が含まれています。

メッセージ ID: pchbadformatstr

## pch collect モード と pch use モードにおけるコンパイラのリリース文字列は互換性がありません

pch collect モード と pch use モードにおけるコンパイラのリリース文字列は互換性がありません。

メッセージ ID: pchbadreleasestr

## pch ファイル内に define が必要でした

pch ファイル内に define が必要でした。

メッセージ ID: pchexpdefines

## pch ファイルに undef が必要でした

pch ファイルに undef が必要でした。

メッセージ ID: pchexpundefs

## pch collect モードと pch use モードでは define 指令が異なります

pch collect モードと pch use モードでは define 指令が異なります。

メッセージ ID: pchbaddefines

## pch collect モードと pch use モードでは undef 指令が異なります

pch collect モードと pch use モードでは undef 指令は異なります。

メッセージ ID: pchbadundefs

## pch collect モードと pch use モードでは保存接頭部が異なります

pch collect モードと pch use モードでは保存接頭部が異なります。

メッセージ ID: pchbadviableprefix

## テンプレートの入れ子の深さが無効です

テンプレートの入れ子の深さが無効です。 このエラーメッセージを生成するコードの例を次に示します。

    template  template
    void foo();	// エラー: テンプレートの入れ子の深さが無効

    struct S {
        template  template
        void foo();	// エラー: テンプレートの入れ子の深さが無効
    }

メッセージ ID: badnesttmpl

## 共有ループ制御変数が非公開にされました

parallel for 内のループ制御で使用される変数は、暗黙的に非公開と宣言されます。このため、shared() 節はこのような変数には何の効果もありません。 このメッセージを生成するコードの例を次に示します。

    int main() {
        int i,j;
        #pragma omp parallel for shared(i,j)
        for (i=0; i<10; i++) j = i;	;     return 0; }

メッセージ ID: omp_shared_control_var

## 静的非 POD 宣言は並列領域では許可されません

並列領域では静的な非 POD 宣言は許可されません。 このエラーメッセージを生成するコードの例を次に示します。

    class A {public: int i; A(){i = 10;};};
    #pragma omp parallel
    {
        static A a;
        ;
    }

メッセージ ID: omp_staticclassdecl

## U 文字列リテラルは ASCII だけを含むことができます

この警告を生成するコードの例を次に示します。

    unsigned short bar[] = U"é";

メッセージ ID: ustronlyascii

## U 文字列リテラルは数値エスケープを含むことはできません

この警告を生成するコードの例を次に示します。

    unsigned short bar[] = U"\351";

メッセージ ID: ustrnoescape

## #pragma hdrstop または -xpchstop ポイントが欠如しているか、あるいは不正に配置されている可能性があります

#pragma hdrstop または -xpchstop ポイントが欠如しているか、あるいは不正に配置されている可能性があります。

メッセージ ID: pchbadstoppoint

## 保存接頭部で許可されるのはコメントと一部のプリプロセッサ指令だけです

保存接頭部で許可されるのはコメントと一部のプリプロセッサ指令だけです。

メッセージ ID: pchbadviablepref