このメッセージは、コンパイラの内部エラーが発生した場合に表示されます。 エラーの状況をまとめご購入先に連絡してください。
メッセージ 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 であり、値を代入することはできません。 このエラーメッセージを生成するコードの例を次に示します。
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
関数呼び出し中の仮引数の型が関数のパラメータと一致しません。 この警告メッセージを生成するコードの例を次に示します。
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
関数呼び出し中の仮引数の型が関数のパラメータと一致しません。
メッセージ 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
型にアクセス不能なコンストラクタがあります。 このエラーメッセージを生成するコードの例を次に示します。
class A {
A(A& a) { }; // ユーザー定義の非公開のコピーコンストラクタ
public:
A() {};
};
A the_a;
void foo(A a) { };
void bar() { foo(the_a); }; // エラー: foo(A) の呼び出し中の型 A の仮引数に
// アクセス不能なコピーコンストラクタがある
メッセージ ID: badcopyaccw
関数呼び出し内の仮引数のオブジェクト型に、アクセス可能なコピーコンストラクタがありません。この仮引数は新しいオブジェクトにコピーできません。 このエラーメッセージを生成するコードの例を次に示します。
class A {
A(A &a); // ユーザー定義の非公開のコピーコンストラクタ
public:
A();
void foo(A a);
} a1, a2;
int main() {
a2.foo(a1); // エラー: A(A&) は非公開
};
メッセージ ID:badcopyacc2w
オブジェクトの型が配列型ではないため配列演算子を使用することはできません。 このエラーメッセージを生成するコードの例を次に示します。
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
明示的な代入演算子を指定する必要があります。 このエラーメッセージを生成するコードの例を次に示します。
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 文は、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 変換は不当です。これらの型は互換性がありません。 このエラーメッセージを生成するコードの例を次に示します。
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 型への変換は不当です。 この警告メッセージを生成するコードの例を次に示します。
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
同じスコープ内に、デフォルト引数が異なる同じテンプレート宣言を指定することはできません。 このエラーメッセージを生成するコードの例を次に示します。
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 文が必要です。 このエラーメッセージを生成するコードの例を次に示します。
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
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 によって迂回されているブロック内で変数が宣言されています。 この警告メッセージを生成するコードの例を次に示します。
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 進数が必要です。 このエラーメッセージを生成するコードの例を次に示します。
#0x12 // エラー #line 0xff "file.cc" // エラー #line 12345 "file.cc" // ok
メッセージ ID: badlinedir
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 の戻り型が必要です。 このエラーメッセージを生成するコードの例を次に示します。
void main() {}
メッセージ ID: badmain
規格では、main() 関数のアドレスをとることは不当です。 このエラーメッセージを生成するコードの例を次に示します。
int main()
{
int *a = main;
return 0;
}
メッセージ ID: badmainaddr
main の再帰呼び出しは許可されていません。 このエラーメッセージを生成するコードの例を次に示します。
int main()
{
main();
return 0;
}
メッセージ ID: badmaincall
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 進定数に使用できるのは数字の 0 〜 7 です。 このエラーメッセージを生成するコードの例を次に示します。
int i = 08; // エラー: 8 は 8 進数に認められていない数字
メッセージ ID: badoctal
多重定義された関数のうち、"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 型の値でなければなりません。 このエラーメッセージを生成するコードの例を次に示します。
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 は許可されません。 このエラーメッセージを生成するコードの例を次に示します。
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
静的キャストが認められるのは、ある型から別の型への暗黙の変換が存在する場合だけです。 このエラーメッセージを生成するコードの例を次に示します。
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
文字列リテラルの値が大きすぎて、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 を使用できるのは静的でないメンバー関数だけです。 このエラーメッセージを生成するコードの例を次に示します。
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 ビットよりも小さいサイズには設定できません。 このエラーメッセージを生成するコードの例を次に示します。
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 へのキャストが試みられました。 このエラーメッセージを生成するコードの例を次に示します。
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: xcastawayconst
このエラーは現在実装されていません。 不完全で 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 つの例外だけです。 このエラーメッセージを生成するコードの例を次に示します。
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 つの例外ハンドラがなければなりません。 このエラーメッセージを生成するコードの例を次に示します。
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
コンパイラが、整数値のゼロ除算が行われておりオーバーフローすると判断しました。 このエラーメッセージを生成するコードの例を次に示します。
int i = 1/0;
メッセージ ID: divovfl
ゼロ除算が試みられていますが、処理は実行時に持ち越されました。 この警告メッセージを生成するコードの例を次に示します。
int i = 9; int j = i/0;
メッセージ ID: divovflnv
その switch 文に default 文が 2 つ存在します。 このメッセージを生成するコードの例を次に示します。
f(void){
long i = 5;
switch(i) {
case 1:
case 2:
break;
default:
default: // エラー: デフォルト文が複数存在する
}
}
メッセージ ID: doubdefault
下線が連続して 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 文が 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
動的キャストの結果はポインタ型か参照型でなければなりません。 このエラーメッセージを生成するコードの例を次に示します。
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 の演算対象には多様型へのポインタまたは参照が必要です。型に 1 つ以上の仮想関数がありません。 このエラーメッセージを生成するコードの例を次に示します。
class B {};
class D: public B {};
B * pb = new D;
D *pd = dynamic_cast<D*>(pb); // エラー: クラス B に仮想関数がない
メッセージ ID: dynnotpolym
予期された結果は参照型でしたが、演算対象は参照型、ポインタ型、構造体型のどれでもありません。 このエラーメッセージを生成するコードの例を次に示します。
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 の演算対象はポインタ型でなければなりません。 このエラーメッセージを生成するコードの例を次に示します。
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
動的キャストに指定した結果がクラスへのポインタまたは参照ではありません。 このエラーメッセージを生成するコードの例を次に示します。
class B { virtual void foo(); };
class D: public B {
};
B *pb = new D;
D *pd1 = dynamic_cast<int*>(pb); // エラー: dynamic_cast は型 "D*" を指定する必要がある
メッセージ ID: dynnotclass
演算対象がクラスの型を指していません。 このエラーメッセージを生成するコードの例を次に示します。
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(...)" は例外ハンドラブロックの最後のハンドラでなければなりません。 このエラーメッセージを生成するコードの例を次に示します。
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
ファイルが空です。このエラーは、ファイルが C++ ファイルとしてコンパイルされておらず、かつコンパイラが互換モードでない場合に発生します。
メッセージ ID: emptyfile
コメントの最後に到達する前に EOF が検出されました。 このエラーメッセージを生成するコードの例を次に示します。
/* メッセージテキスト . . . <EOF> // エラー
メッセージ ID: eofincomment
テキストの呼び飛ばし中にコンパイラが 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
型が正しく定義されていないか、あるいは記憶スペースが割り当てられていません。 このエラーメッセージを生成するコードの例を次に示します。
class C;
void f ()
{
new C; // エラー: 型 C が完結していない
}
メッセージ ID: incomplete
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 と定義することはできません。 このエラーメッセージを生成するコードの例を次に示します。
class A {
public:
void foo ();
};
int main () {
A a;
a.foo();
}
inline
void A::foo () {}
メッセージ ID: xinlafteruse
この関数は大きすぎるため、コンパイラはインラインを生成できません。
メッセージ 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 を使用せずにマクロを異なる値に再定義することはできません。 このエラーメッセージを生成するコードの例を次に示します。
#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 による剰余計算が試みられました。 このエラーメッセージを生成するコードの例を次に示します。
int i = 1000000 % 0;
メッセージ ID: modovfl
0 による変数剰余の計算が試みられました。この警告の処理は実行時に持ち越されました。 この警告メッセージを生成するコードの例を次に示します。
void foo()
{
int i = 9;
i%0; // 警告: 0 による剰余の計算
}
メッセージ ID: modovflnv
浮動小数点の乗算式がオーバーフローするとコンパイラが判断しました。処理は実行時に持ち越されました。
メッセージ ID: mulfovfl
コンパイラがコンパイル時に乗算結果の計算を試み、結果がオーバーフローすると判断しました。結果の下位 32 ビットが保持され、この診断が発行されます。 このメッセージを生成するコードの例を次に示します。
int i = 1000000 * 1000000;
メッセージ ID: mulovfl
複数の修飾子は許可されていません。
メッセージ 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 が無視されました。
メッセージ ID: noexthrow
コンパイラ引数 -noex が使用されたため、例外機構 try と catch が無視されました。
メッセージ ID: noextry
識別子リストには、")" でリストが終了する前に EOL (行末) が存在します。マクロは 1 行で定義しなければなりません。"\" が抜けている可能性があります。 このエラーメッセージを生成するコードの例を次に示します。
#define foo( A, // "\" が抜けている B )
メッセージ ID: noidentlist
const メンバーオブジェクトは初期化する必要があります。
メッセージ ID: noconstinit
演算子 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 ではどの型も定義できません。 この警告メッセージを生成するコードの例を次に示します。
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" 式では型を定義できません。 このエラーメッセージを生成するコードの例を次に示します。
int foo () {
return sizeof (struct t {}); // エラー: sizeof 式内に struct 宣言が見つかった
}
メッセージ ID: nodefinsizeof
"typeid" 式では型を定義できません。 このエラーメッセージを生成するコードの例を次に示します。
#include <typeinfo>
int main () {
typeid (struct t {}); // エラー: typeid 式内に struct 宣言が見つかった
}
メッセージ ID: nodefintypeid
"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 機能が有効にされていないため、動的キャストは静的キャストで置き換えられました。
メッセージ 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 宣言にクラス、関数とも指定されていません。 このエラーメッセージを生成するコードの例を次に示します。
class A {
int i;
friend;
};
メッセージ ID: nofriendfield
旧式事項です。クラスに対するフレンド指定では明示的な "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
(ccfe): -nocx オプションは、long long および long long const の使用を抑制します。 このエラーメッセージを生成するコードの例を次に示します。
long foo () { return 0ll; } // -nocx オプションが指定される場合はエラー
メッセージ ID: nollconst
(ccfe): -nocx オプションは、long long および long long const の使用を抑制します。 このエラーメッセージを生成するコードの例を次に示します。
long long cll = 0; // -nocx オプションが指定される場合はエラー
メッセージ ID: nolonglong
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 演算子で代入することはできません。 このエラーメッセージを生成するコードの例を次に示します。
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 と宣言されていないメンバー関数を呼び出しました。 このエラーメッセージを生成するコードの例を次に示します。
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 と宣言されていないメンバー関数を呼び出しました。
メッセージ 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 関数だけです。 このエラーメッセージを生成するコードの例を次に示します。
class A {
public:
void foo();
};
int main()
{
A volatile a;
a.foo(); // エラー: A::foo() は volatile 関数でない
}
メッセージ ID: nonvolmf
メンバー関数を 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 が検出されました。 このエラーメッセージを生成するコードの例を次に示します。
void foo()
{
/* コード */
<EOF> // エラー:}" が予期されたが EOF が検出された
メッセージ ID: norcurleof
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 ラベルには整数定数式が必要です。 このエラーメッセージを生成するコードの例を次に示します。
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++ にしか許可されないコードをコンパイラが検出し、この警告を発行しました。
メッセージ ID: notcpp
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 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 文の中だけです。 このエラーメッセージを生成するコードの例を次に示します。
int main()
{
int i = 7;
case 7: // エラー: case 文が switch 文の中にない
i++;
break;
return 0;
}
メッセージ ID: notinsw
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 クラスを使用するには、ファイル 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 は行えません。
メッセージ 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 は値を持ちません。 このエラーメッセージを生成するコードの例を次に示します。
foo()
{
int i = (void)1;
}
メッセージ ID: novoidval
void ポインタを間接参照することはできません。void は値を持ちません。 このメッセージを生成するコードの例を次に示します。
void *i; int j = *i; // エラー: void* は間接参照できない
メッセージ ID: novoidderef
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 指令を使うことはできません。 このエラーメッセージを生成するコードの例を次に示します。
namespace NS { int j; };
class A {
using namespace NS;
};
メッセージ ID: nsdirinclass
参照の初期化式がゼロに評価されています。 このエラーメッセージを生成するコードの例を次に示します。
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
式の int のサイズがオーバーフローしたか、0 による除算がありました。
メッセージ ID: overflow
コンパイラでメモリーが不足です。リソースを一部解放し、再度試してください。
メッセージ ID: outofmem
括弧を付けずに構造体メンバーの初期設定を行うと、"+w2" フラグでコンパイルを行う場合に警告が生成されます。 このエラーメッセージを生成するコードの例を次に示します。
struct B {
int i;
int j;
} X[] = { 1, 2, 3, 4 };
メッセージ ID: partinit
#else 指令には、対応する先行の #if 指令がなければなりません。 このエラーメッセージを生成するコードの例を次に示します。
//#if true #define num 1 #else num 0 // . . .
メッセージ ID: ppbadelse
プリプロセッサ指令 #endif には、対応する #if がなければなりません。
メッセージ ID: ppbadendif
プリプロセッサコマンドの後に、余分なテキストがあります。 このエラーメッセージを生成するコードの例を次に示します。
#include <file.h>; // エラー: 余分な ";" を削除してください
メッセージ ID: ppextra
この行の余分なテキストは 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 をビットフィールドに適用することはできません。 このエラーメッセージを生成するコードの例を次に示します。
class A {
public:
A() { size = sizeof(i); }
int i:3;
int size;
};
メッセージ ID: sizeofbf
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
局所変数が迂回されており、初期設定を行うことはできません。 このエラーメッセージを生成するコードの例を次に示します。
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 ポインタの変換はテンプレートパラメータに適用できないため、この場合、エラーが発生します。 このエラーメッセージを生成するコードの例を次に示します。
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 つ含んでいます。 この警告メッセージを生成するコードの例を次に示します。
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 回初期化されました。 このエラーメッセージを生成するコードの例を次に示します。
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 でサポートされるのは、符号付きまたは符号なし整数のビットフィールドだけです。
メッセージ 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* に変換しました。 この警告メッセージを生成するコードの例を次に示します。
void foo () {
char *s;
s = "abcd"; // 警告
}
メッセージ ID: wbadasgl
異なる型を使用して型を初期化しているために警告が出力されました。
メッセージ ID: wbadinit
文字列リテラルを使用して異なる互換型が初期化されました。
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
init プラグマまたは fini プラグマにパラメータとして渡せるのは引数を持たない void 関数だけです。 このエラーメッセージを生成するコードの例を次に示します。
void my_fini (int a) { }
#pragma fini(my_fini)
メッセージ ID: prbadfunc
一部のプラグマは、1 つ以上のパラメータが渡されることを要求します。 このエラーメッセージを生成するコードの例を次に示します。
#pragma fini ()
メッセージ ID: premptylist
境界整列で指定する値は、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 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 の後に文字列リテラルが抜けています。
メッセージ ID: prnostr
プラグマ引数の区切り文字として不正な記号が使用されました。 このエラーメッセージを生成するコードの例を次に示します。
void my_init1 () { }
void my_init2 () { }
void my_init3 () { }
#pragma init(my_init1,my_init2.my_init3)
メッセージ ID: prnocomma
プラグラマパラメータリストは、'(' で始まる必要があります。 このエラーメッセージを生成するコードの例を次に示します。
void my_init1 () { }
#pragma init my_init1)
メッセージ ID: prnolp
パラメータリスト内に ')' が抜けているか不正な記号が検出されました。 このエラーメッセージを生成するコードの例を次に示します。
void my_init1 () { }
void my_init2 () { }
void my_init3 () { }
#pragma init(my_init1,my_init2.my_init3)
メッセージ ID: prnorp
このメッセージは、エラーメッセージと共に行番号を表示するためにコンパイラによって使用されます。
メッセージ ID: linetheword
asm 文には文字列リテラルがなければなりません。 このエラーメッセージを生成するコードの例を次に示します。
void foo()
{
asm( nop ); // エラー
}
メッセージ ID: noasmstring
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 は、const と宣言されたクラスオブジェクト内のフィールドを変更できるようにするために使用します。 このエラーメッセージを生成するコードの例を次に示します。
void foo()
{
mutable int i = 0; // エラー
}
class A {
mutable int i; // ok
};
メッセージ ID: mutclassonly
mutable を使用できるのはメンバーデータに対してだけです。 このエラーメッセージを生成するコードの例を次に示します。
class A {
public:
mutable int i; //ok
mutable void foo() {} // エラー
A() {}
};
メッセージ ID: mutnofunc
const と宣言された名前を同時に mutable と宣言することはできません。 このエラーメッセージを生成するコードの例を次に示します。
class A {
public:
A(int j) { i = j; };
mutable const int i; // エラー
};
メッセージ ID: mutnoconst
静的データメンバーは mutable にはできません。 このエラーメッセージを生成するコードの例を次に示します。
class A {
public:
mutable static int i;
};
メッセージ ID: mutdatamems
多重定義された演算子は 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 で宣言された変数はサポートされていません。 型を指定する必要があります。 この警告メッセージを生成するコードの例を次に示します。
i[] = {1, 2, 3};
メッセージ ID: noimplint
テンプレート宣言内に 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
クラスが "->" 演算子を多重定義しました。この演算子はクラス型の値を返します。 このエラーメッセージを生成するコードの例を次に示します。
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 の乗数です。 このエラーメッセージを生成するコードの例を次に示します。
#pragma pack (3)
メッセージ ID: prbadpack
extern C リンケージを使用してテンプレートを宣言することはできません。 このエラーメッセージを生成するコードの例を次に示します。
extern "C"
template <class t_arg> class A {}; // エラー: テンプレート宣言はこのリンケージを持つことができない
メッセージ ID: temnotexternc
型名がテンプレートパラメータで修飾される場合、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
テンプレート関数はフレンドとして宣言できません。 このエラーメッセージを生成するコードの例を次に示します。
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
このエラーメッセージを生成するコードの例を次に示します。
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
メッセージ ID: tdb_version
コマンド行上に複数の -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 演算子を適用してはなりません。 このエラーメッセージを生成するコードの例を次に示します。
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
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' が抜けている可能性があります。 このエラーメッセージを生成するコードの例を次に示します。
templateclass 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
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
互換モードで全プログラムの最適化 (-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 void (*pf) () throw();
メッセージ ID: badexceptionspec
関数ポインタは、割り当てられる関数ポインタを通してのみ例外を送出できます。この警告を生成するコードの例を次に示します。
void (*pf1)();
void (*pf2)() throw(int);
void f() {
pf2 = pf1;
}
メッセージ ID: fptrthrow
このメッセージを生成するコードの例を次に示します。 int NE_C2_3() { int a = 1;
#pragma omp parallel if ( a> 1 ) if ( a < 5 ) { } return 0; }
メッセージ ID: omp_extraclause
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
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" OpenMP pragma は "sections" ブロックのすぐ内側に配置する必要があります。 このメッセージを生成するコードの例を次に示します。
int NE_C2_4_2_1()
{
#pragma omp sections
{
;
}
#pragma omp section
{
}
return 0;
}
メッセージ ID: omp_sectionoutsidesections
このメッセージを生成するコードの例を次に示します。
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 指令はファイルスコープまたはネームスペーススコープになければならず、かつどのような定義または宣言よりも外側になければなりません。 このメッセージを生成するコードの例を次に示します。
int a=0;
class A
{
#pragma omp threadprivate ( a )
};
int NE_C2_7_1_1b()
{
return a;
}
メッセージ ID: omp_nonfilethreadprivate
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 変数は、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
このメッセージを生成するコードの例を次に示します。
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 変数でなければなりません。 このメッセージを生成するコードの例を次に示します。
int x;
int NE_C2_7_2_7_2()
{
#pragma omp parallel copyin (x)
{
}
return 0;
}
メッセージ ID: omp_copyinnotthreadprivate
同じ名前の 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 指令は、それぞれの入れ子のなかでは使用することができません。 このメッセージを生成するコードの例を次に示します。
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 指令を含む最小の文はブロック (または複合文) でなくてはなりません。 このメッセージを生成するコードの例を次に示します。
int NE_C2_6_5_2()
{
int i = 5;
#pragma omp parallel
{
if ( i> 0 )
#pragma omp barrier
}
return 0;
}
メッセージ ID: xomp_mustbeblock
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 0 "file.cc"
メッセージ ID: poslinenum
並列領域内で非公開 (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 プラグマで一般構文エラーが検出されると表示されます。 このメッセージを生成するコードの例を次に示します。
int main()
{
#pragma omp parallel private
{
}
return 0;
}
メッセージ ID: omp_badlyformedomppragma
OpenMP の for ループの制御式は、以下の標準の形式でなくてはなりません:
メッセージ ID: omp_forbadcontrol
int main()
{
int i,j=0;
#pragma omp parallel for
for (i=0; j<10; i++) { } return 0; }
デフォルトの節に使用できる値は none または shared のみです。 このメッセージを生成するコードの例を次に示します。
int main()
{
int i;
#pragma omp parallel default(private)
{
i++;
}
return 0;
}
メッセージ ID: omp_baddefault
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
このメッセージを生成するコードの例を次に示します。
int main()
{
#pragma omp unknown
return 0;
}
メッセージ ID: omp_badomppragma
OpenMP 並列構造とワークシェアリング構造には、そのあとに構造体ブロックが続くことが必要とされています。構造体ブロックは、1 つの入り口と 1 つの出口をもつ文です。構造体ブロックに入ったり、構造体ブロックから出たりする文を使用することはできません。つまり、構造体ブロックには、制御をブロックから別の場所に移すような return、goto、break、または continue などの文は使用できません。 このメッセージを生成するコードの例を次に示します。
int foo() {
#pragma omp parallel
{
return 1;
}
}
メッセージ ID: omp_strblkviolation
OpneMP の for ループの反復式は標準の形式をもっている必要があります。 このメッセージを生成するコードの例を次に示します。
int main() {
int i;
#pragma omp parallel for
for (i=0; i<10; foo(&i)) { } return 0; }
メッセージ ID: omp_forbaditer
OpenMP の for ループの初期値式は以下のような標準の形式をもっていなければなりません。
メッセージ ID: omp_forbadinit
int main() {
int i=0;
#pragma omp parallel for
for (; i<10; i++) { } return 0; }
OpenMP の後に、プラグマ用に for 文を使用する必要があります。 このメッセージを生成するコードの例を次に示します。
int main() {
int i=0;
#pragma omp parallel for
{
while( 0 ){
i++;
}
return 0;
}
メッセージ ID: omp_forbadfollow
\"%1\" の宣言は構文上あいまいです。標準では関数の宣言と解釈されます。 これに対し、プログラマはオブジェクトの宣言を意図している場合がよくあります。 混同を避けるため、構文上明確な方法で宣言し直してください。 この警告メッセージを生成するコードの例を次に示します。
struct T { };
T t( T() ); // t は関数
構文上明確な、推奨される代替の記述は次のとおりです。
T t( (T()) ); // t はオブジェクト (型に余分な括弧は記述できない) T t = T(); // t はオブジェクト (代入による初期化) T t( T(*)() ); // t は関数 (明示的関数ポインタ)
メッセージ ID: ambigfuncdecl
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 指令は、お互いの中で入れ子にすることができません。 このメッセージを生成するコードの例を次に示します。
void main(void) {
#pragma omp critical(foo)
#pragma omp critical(foo)
;
}
メッセージ ID: omp_badcriticalnesting
ネイティブと宣言された Java メソッドは、C++ 関数を使用して実装する必要があります。前もって .class ファイルでネイティブメソッドと宣言されていない場合は、メソッドの C++ バージョンを指定するとエラーになります。
メッセージ ID: notjavanative
可変引数として非 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 宣言にクラス、関数とも指定されていません。 このエラーメッセージを生成するコードの例を次に示します。
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 に対する有効な引数は、defs、undefs、loc、conds、および sys です。 このエラーメッセージを生成するコードの例を次に示します。
#pragma dumpmacros(definitions)
メッセージ ID: prbadarg
深さが入れ子になっているテンプレートで関数テンプレートの特殊化が指定されていますが、使用できるのは非テンプレート関数だけです。 このエラーメッセージを生成するコードの例を次に示します。
templatestruct A { void f(int); }; template<> template <> void A ::f(int) {} // 仕様範囲外
メッセージ ID: mismatchtmpdepth
64 ビットへの移植の際に、代入、初期化、またはキャストによってデータが切り捨てられることがあります。 このエラーメッセージを生成するコードの例を次に示します。
long l; (int)l;
メッセージ ID: truncwarn1
64 ビットへの移植の際に、unsigned long に代入される前にデータの符号が拡張される可能性があります このエラーメッセージを生成するコードの例を次に示します。
int i; unsigned long ul = i;
メッセージ ID: signextwarn
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 指令に指定されたブロックスコープ変数は静的でなければなりません。 このメッセージを生成するコードの例を次に示します。
int main() {
#pragma omp parallel
{
int i;
#pragma omp threadprivate(i)
i = 50;
}
}
メッセージ ID: omp_threadprivatenotstatic
静的なブロックスコープ変数の threadprivate 指令は、入れ子になったスコープではなく変数のスコープ内に存在する必要があります。 このメッセージを生成するコードの例を次に示します。
int main() {
static int i;
#pragma omp parallel
{
#pragma omp threadprivate(i)
i = 50;
}
}
メッセージ ID: omp_threadprivateinnested
OpenMP parallel の if 節に指定された式は、スカラー型である必要があります。 このメッセージを生成するコードの例を次に示します。
int main() {
struct { float val; } good = {3.62};
#pragma omp parallel if(good)
good.val = 4.12;
}
メッセージ ID: omp_badiftype
OpenMP parallel の num_threads 節に指定された式は、整数型である必要があります。 このメッセージを生成するコードの例を次に示します。
int main() {
int i = 0;
#pragma omp parallel num_threads(3.62)
i++;
}
メッセージ ID: omp_badnumthreadstype
テンプレート引数の宣言ではクラス定義は指定できません。 このエラーメッセージを生成するコードの例を次に示します。
templateclass S{};
メッセージ ID: noclassdef
copyprivate 節は nowait 節とともに使用してはなりません。 このメッセージを生成するコードの例を次に示します。
int main() {
int i = 42;
#pragma omp single nowait copyprivate(i)
{
i++;
}
}
メッセージ ID: omp_badusecopyprivate
copyprivate 節をもつ単一の指令が並列領域の動的範囲内で検出される場合、copyprivate 節内に指定された変数はすべてこの閉じたコンテキストにおいて非公開でなければなりません。 このメッセージを生成するコードの例を次に示します。
int main() {
int i = 1;
#pragma omp parallel
{
i = 42;
#pragma omp single copyprivate(i)
{
i++;
}
}
}
メッセージ ID: omp_notprivateincontext
const 変数は、宣言子と初期設定子を使用して宣言する必要があります。 このメッセージを生成するコードの例を次に示します。
const enum E1 {a, b}; // エラー
const enum E2 {c, d} x = c; // ok
メッセージ ID: badconstdecl
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
この警告メッセージを生成するコードの例:
#includeint 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
メッセージ ID: demxarchv8plus
このメッセージを生成する例を次に示します。
struct S {
int f1(int = f2());
int f2(int = f1());
};
メッセージ ID: recurseindefault
仮想関数はフレンド関数として宣言することはできません。 このエラーメッセージを生成するコードの例を次に示します。
void foo() { return; }
void goo() { return; }
class A {
virtual friend void foo(); // エラー
virtual friend void A::goo(); // エラー
};
メッセージ ID: virtfriendfunction
フレンド関数が関数名だけで宣言されました。 このエラーメッセージを生成するコードの例を次に示します。
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
この警告メッセージを生成するコードの例:
namespace N {
template struct ap {
ap(X* p = 0);
};
};
using namespace N;
class A { };
A* a;
ap ap(a) ;
メッセージ ID: baddeclare
この警告メッセージを生成するコードの例を次に示します。
class A {
};
main()
{
A a(10);
#pragma omp parallel private(a)
{
;
}
}
メッセージ ID: nodefctor
この警告を生成するコードの例を次に示します。
templateclass A { ... }; class A ; // 警告: 無視されます template<> class A ; // 明示的な特殊化の宣言 template class A ; // 明示的なインスタンス化指令
メッセージ ID: oldspecialdecl
この警告を生成するコードの例を次に示します。
__thread void func();
struct type {
__thread void func();
};
メッセージ ID: nothreadfuncs
この警告を生成するコードの例を次に示します。
int changed; __thread int changed;
メッセージ ID: threaddeclfirst
__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
この警告を生成するコードの例を次に示します。
void func() {
__thread int a;
}
メッセージ ID: noautothread
この警告を生成するコードの例を次に示します。
templatestruct 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
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
1 つのセクションに複数の文が含まれる場合は、それらを {} 内に配置する必要があります。 このメッセージを生成するコードを示します。
#pragma omp sections
{
// 任意の #pragma omp セクション
x = 5;
y = 10;
}
メッセージ ID: omp_badsectionstructure
フレンド関数名がもっとも近い名前空間で宣言されているテンプレートを使用していないか、あるいは現在のクラス内で宣言されているものを使用しています。 このエラーメッセージを生成するコードの例を次に示します。
#includenamespace 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::valarrayconst Fu<>( Bar // Fu<> は名前空間 M 内に宣言をもたない } ; };const & ) ;
メッセージ 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
この警告を生成するコードの例を次に示します。
char c[100000]; short i = sizeof(c);
メッセージ ID: truncwarn2
参照メンバーをもつクラスは、ユーザー定義のコンストラクタが存在しなければなりません。 このエラーメッセージを生成するコードの例を次に示します。
struct S {
int x&;
};
メッセージ ID: refmemnoconstr
使用されている pch ファイルに正しいマジック番号が存在しません。
メッセージ ID: pchbadmagicnumber
使用されている pch ファイルのフロントに、不正なフォーマット文字列が含まれています。
メッセージ ID: pchbadformatstr
pch collect モード と pch use モードにおけるコンパイラのリリース文字列は互換性がありません。
メッセージ ID: pchbadreleasestr
pch ファイル内に define が必要でした。
メッセージ ID: pchexpdefines
pch ファイルに undef が必要でした。
メッセージ ID: pchexpundefs
pch collect モードと pch use モードでは define 指令が異なります。
メッセージ ID: pchbaddefines
pch collect モードと pch use モードでは undef 指令は異なります。
メッセージ ID: pchbadundefs
pch collect モードと pch use モードでは活性文字列が異なります。
メッセージ ID: pchbadviableprefix
テンプレートの入れ子の深さが無効です。 このエラーメッセージを生成するコードの例を次に示します。
templatetemplate 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 宣言は許可されません。 このエラーメッセージを生成するコードの例を次に示します。
class A {public: int i; A(){i = 10;};};
#pragma omp parallel
{
static A a;
;
}
メッセージ ID: omp_staticclassdecl
この警告を生成するコードの例を次に示します。
unsigned short bar[] = U"é";
メッセージ ID: ustronlyascii
この警告を生成するコードの例を次に示します。
unsigned short bar[] = U"\351";
メッセージ ID: ustrnoescape
#pragma hdrstop または -xpchstop ポイントが欠如しているか、あるいは不正に配置されている可能性があります。
メッセージ ID: pchbadstoppoint
活性文字列で許可されるのはコメントと一部のプリプロセッサ指令だけです。
メッセージ ID: pchbadviablepref
開いているファイルが多すぎます。自身を取り込むファイルである可能性があります。
メッセージ ID: toomanyopenfiles
const または volatile のキャストが試みられました。 このエラーメッセージを生成するコードの例を次に示します。
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 ではないポインタにキャストする。
extern int *const** p1;
int **const* p2 = reinterpret_cast<int **const*>(p1); // エラー
extern volatile int *pi;
int *pi2 = static_cast<int*>(pi); // エラー
メッセージ ID: castawayconst
threadprivate 指令は、あらゆる定義または宣言の外部でなければなりません。 このメッセージを生成するコードの例を次に示します。
class A
{
int a;
#pragma omp threadprivate ( a )
};
メッセージ ID: omp_badthreadprivate
template 宣言で明示的なテンプレート引数リストは使用できません。 このメッセージを生成するコードの例を次に示します。
templatevoid bar (); template void bar ();
メッセージ ID: wexpltemplid
atomic pragma の後は 1 つの式の文である必要があります。 このメッセージを生成するコードの例を次に示します。
#pragma omp atomic
{ // 「{」は許されない
i++;
}
メッセージ ID: omp_badatomicfollow
関数が、インラインで宣言する前に使用されています。このことは、先行するすべての呼び出しが extern として処理されることを意味します。以降の呼び出しがインライン化されます。 このエラーメッセージを生成するコードの例を次に示します。
class A {
public:
void foo();
};
int main() {
A a;
a.foo();
}
inline
void A::foo () {}
メッセージ ID: inlafteruse
符号付きと符号なしの型を比較しています。 このメッセージを生成するコードの例を次に示します。
int foo(unsigned ui, int i) {
if ( ui < i )
return 0;
else
return 1;
}
メッセージ ID: wunsignedcomp
for 構文のループの反復処理内で、複数の ordered 指令を実行してはいけません。 このメッセージを生成するコードの例を次に示します。
int main() {
#pragma omp for ordered
for (int q = 0; q < 100; q++) {
#pragma omp ordered
{
int a;
}
#pragma omp ordered
{
int b;
}
}
}
メッセージ ID: omp_badordered
局所クラスに対して friend 宣言する関数またはクラスが、クラスの外の最も内側のスコープ中に見つかりませんでした。 この警告を生成するコードの例を次に示します。
void global_f();
class A {};
void f() {
extern void another_f();
class B {};
class local_class {
friend void f(); // 警告
friend void global_f(); // 警告
friend void another_f(); // Ok
friend class A; // 警告
friend class B; // Ok
};
}
メッセージ ID: badlocalfrienddecl
いくつかの OpenMP 指令には、使用に制約があります。 このメッセージを生成するコードの例
void foo() {
int i = 0;
label:
#pragma omp barrier
i++;
goto label;
}
メッセージ ID: omp_mustbeblock
barrier および flush 単独指令にラベルは付けられません。 このメッセージを生成するコードの例
main() {
int i = 0;
#pragma omp parallel
{
label:
#pragma omp flush
i++;
goto label;
}
}
メッセージ ID: omp_no_label
pch ファイルに srcdir が含まれていません。
メッセージ ID: pchexpsrcdir
pch collect モードと pch use モードでソースディレクトリが異なります。
メッセージ ID: pchbadsrcdir
pch ファイル内に cwd が含まれていません。
メッセージ ID: pchexpcwd
pch collect モードと pch use モードで現在のディレクトリが異なります。
メッセージ ID: pchbadcwd
pch ファイル内に options が含まれていません。
メッセージ ID: pchexpoptions
pch collect モードと pch use モードでオプションが異なります。
メッセージ ID: pchbadoptions
try は、例外をスローしたスレッドによってキャッチされる必要があるため、OpenMP 構文を try ブロック内で使用することはできません。 このメッセージを生成するコードの例
try {
#pragma omp parallel
{
throw a();
}
}
catch(...) {
printf("in catcher\n");
} }
メッセージ ID: omp_in_guarded
規格では、omp sections コンストラクトの後に { section-sequence } が現れる必要があります。 このメッセージを生成するコードの例
#pragma omp parallel sections
i = i + 5;
メッセージ ID: omp_nosectionscope
正当な atomic 式に関する規則については、OpenMP API を参照してください。 このメッセージを生成するコードの例
#pragma omp atomic
i = i + 5;
メッセージ ID: omp_badatomicexpr
規格では、ループ内でのインデックス変数の OpenMP 値の変更は禁止されています。 このメッセージを生成するコードの例
#pragma omp parallel for
for (i = 0; i < 10; i++) {
i = i + 5;
}
メッセージ ID: omp_forindexmod
テンプレートのフレンド宣言で、パラメータ数は同数である必要があります。 このエラーメッセージを生成するコードの例を次に示します。