跳转到内容

GCC 调试/g++/错误

Add links
来自 Wikibooks，开放书籍，开放世界

抽象声明符 'TYPE' 用作声明

[编辑 | 编辑源代码]
  • 在 GCC 版本 4.5.1 中找到的消息
    • 通常与以下内容一起分组
      • 成员 'DATA_MEMBER' 在匿名聚合体中不允许使用构造函数
      • 成员 'DATA_MEMBER' 在匿名聚合体中不允许使用析构函数
      • 成员 'DATA_MEMBER' 在匿名聚合体中不允许使用复制赋值运算符
  • 类或结构体缺少名称
struct {  // error, no name
   int bar;
};
  • 头文件中包含一个类或结构体，其名称已在 ifndef、define 语句中使用
#ifndef foo
#define foo
#include <vector>

struct foo {  // error, foo already in use
   std::vector<int> bar;
};

#endif

重载 'FUNCTION' 的调用不明确

[编辑 | 编辑源代码]

'VARIABLE' 不能出现在常量表达式中

[编辑 | 编辑源代码]

'VARIABLE' 不能用作函数

[编辑 | 编辑源代码]
  • 在 GCC 版本 4.5.1 中找到的消息
  • 确保变量名中不包含下划线（编译器怪癖）
  • 在函数定义中，使用相同的名称作为变量名和函数名
int foo(int baf) { return baf; }
 
int bar(int foo) {
   foo = foo(4);
   return foo; 
}

请求从 'TYPE' 到非标量类型 'TYPE' 的转换

[编辑 | 编辑源代码]
  • 在 GCC 版本 4.5.1 中找到的消息
  • 类型转换错误，查找缺少 "::" 语法或缺少括号
  • 可能是强制转换错误
  • 类成员函数返回的值与函数声明的返回类型不匹配
class Foo {
public:
   int x;
};
 
class Bar {
public:
   Foo Maz() { return 0; }  // 0 is of type int, not Foo
};

无法将 'STATEMENT' 转换为 'bool'

[编辑 | 编辑源代码]
  • 在 GCC 版本 3.2.3、4.5.1 中找到的消息
  • 输入的比较运算符错误（例如：使用 "=" 而不是 "=="）
  • 调用函数的定义使用了不正确的返回类型
// you had: 
foo operator<(const foo & f) const

// instead of:
bool operator<(const foo & f) const
  • 使用无效的参数进行条件语句
string x = "foo";
if (x) cout << "true" << endl;

在类外部声明 'FUNCTION' 不是定义

[编辑 | 编辑源代码]
  • 在 GCC 版本 3.2.3、4.5.1 中找到的消息
  • 尝试使用 '=' 初始化值，而不是括号
  • 在构造函数和初始化列表之间使用分号或逗号，而不是冒号
  • 在函数定义的主体之前遗漏分号
class Foo 
{
public:
   int bar;
   Foo(int x);
}; 
 
Foo::Foo(int x);  // semicolon ';' needs to be removed
{
   bar = x;
}

'VARIABLE' 的声明隐藏了参数

[编辑 | 编辑源代码]
  • 在 GCC 版本 3.2.3、4.5.1 中找到的消息
  • 重新定义了已经在使用的变量名，可能在函数的参数列表中声明过
int foo(int bar)
{
   int bar;
   return bar;
}

'TYPE' 不是类型名

[编辑 | 编辑源代码]
  • 在 GCC 版本 4.5.1 中找到的消息
    • 在 GCC 版本 3.2.3 中，有时报告为：在 'CHARACTER' 标记之前出现语法错误
    • 在 GCC 版本 4.0.1 中，有时报告为：ISO C++ 禁止声明
      • 例如：ISO C++ 禁止声明没有类型的 'vector'
  • 遗漏了对象的名称限定符或使用指令
ostream & os;  // instead of: std::ostream & os;
  • 确保没有输入作用域运算符 "::" 的错误，例如：使用 "name:name" 而不是 "name::name"
  • 确保包含了所需的库
#include <iostream>
// missing vector library include
class Foo {
public:      
   std::vector<int> Bar(std::vector<int> FooBar) { return FooBar; }
};
  • 在包含指令中，头文件列在使用它的文件之后
// test.h file
#ifndef TEST_H_
#define TEST_H_
std::string bar;
#endif

// test.cpp file
#include "test.h"
#include <iostream>  // error, needed before test.h
using namespace std;

int main()
{
   cout << bar << endl;
   return 0;
}

在 'TOKEN' 标记之前预期 'TOKEN'

[编辑 | 编辑源代码]
  • 在 GCC 版本 3.2.3、4.5.1 中找到的消息
    • 在 GCC 版本 3.2.3 中，有时报告为：在 'CHARACTER' 标记之前出现语法错误
  • 检查函数参数中是否缺少逗号或括号
  • 检查是否缺少分号
    • 例如：在 'TOKEN' 之前预期 ',' 或 ';'
const int MAX = 10  // error

int main() {
   string foo;
   cout << foo.size();
   return 0;
}
  • 可能来自双重命名空间定义，或者已经存在于 'using' 指令下的完全限定（例如：std::cout）名称
  • 可能在 cin/cout 语句中缺少 '<<' 或 '>>' 运算符
int foo = 0, bar = 0;
cin foo >> bar;  // should be: cin >> foo >> bar;

在 'TOKEN' 之前预期主表达式

[edit | edit source]
在 'int' 之前预期为初等表达式
  • 在 GCC 版本 4.5.1 中找到的消息
    • 在 GCC 3.2.3 版本中报告为：解析错误，在 ')' 标记之前
  • 一个可能的原因是在函数调用中使用（或保留）类型名称
int sum(int x, int y) { return (x + y); }

int main() {
   int a = 4, b = 5;
   sum(a, int b); // int is the problem causer
   return 0;
}

在 'TOKEN' 之前预期为非限定标识符

[edit | edit source]
  • 在 GCC 版本 4.5.1 中找到的消息
  • 检查语法是否有遗漏、错位或错误的字符
  • 在 '(' 标记之前预期为非限定标识符
    • 例如：类名中的括号
class Foo() {
public:
   int x;
};
  • 在 'return' 之前预期为非限定标识符
    • 例如：条件语句中缺少左花括号
int foo = 3, bar = 2;
if (foo > bar)  // error, no "{"
   cout << foo << endl;
}

将 'TYPE' 赋值给 'TYPE' 时类型不兼容

[edit | edit source]
  • 在 GCC 4.5.1 版本中找到的错误信息
  • 您试图使用字符指针来为字符数组赋值或初始化
    • 例如：将 'const char*' 赋值给 'char [10]' 时类型不兼容
char bar[10];
const char *foo = "ppp";
bar = *foo;  // error

// possible fix, use strcpy from the cstring header:
char bar[10];
const char *foo = "ppp";
strcpy(bar, foo);
  • 不正确地访问二维数组的元素
char foo[2][3];
foo[1] = ' '; // error, need both dimensions, eg: foo[1][0] = ' ';

从 'TYPE' 到 'TYPE' 的无效转换

[edit | edit source]
  • 在 GCC 版本 3.2.3、4.5.1 中找到的消息
  • 确保没有遗漏函数名称的括号
  • 确保为函数传递了正确的参数
char foo = 'f';
char bar[] = "bar";
if (strcmp(foo, bar) != 0)
   cout << "Correct answer!";
// strcmp was expecting 2 character pointers, foo doesn't qualify

'TYPE' 和 'TYPE' 类型对二元运算符 'FUNCTION' 的无效操作数

[edit | edit source]
  • 在 GCC 版本 4.5.1 中找到的消息
  • 您试图使用加号运算符连接 C 字符串参数
// attempting to combine two C-strings
cout << "abc" + "def";

// possible fix: convert 1 argument to a string type
cout << "abc" + string("def");

无效的模板名称使用

[edit | edit source]
无效的模板名称 'TEMPLATE' 使用，没有参数列表
  • 在 GCC 版本 4.5.1 中找到的消息
    • 通常与以下错误信息配对：在 'TOKEN' 之前预期为非限定标识符
    • 在 GCC 3.2.3 版本中报告为：在 'CHARACTER' 标记之前出现语法错误
  • 函数定义中缺少类名后的类型
template <class T> class Foo {
private:
   int x;
public:
   Foo();
};

template<class T> Foo::Foo() { x = 0; }  // error, should be: Foo<T>::Foo()

不是成员

[edit | edit source]
  • 在 GCC 4.5.1 版本中找到的错误信息
  • 检查是否缺少头文件包含
例如：'cout' 不是 'std' 的成员
// test.cpp
// file is missing iostream include directive
int main() {
   std::cout << "hello, world!\n";
   return 0;
}

'TYPE' 不是类型

[edit | edit source]
  • 在 GCC 版本 4.5.1 中找到的消息
    • 在 GCC 3.2.3 版本中报告为：参数 'PARAMETER' 缺少类型说明符
  • 您在函数声明中误输入了模板参数
void foo(int x, vector y);
  • 包含的头文件中没有包含源文件中实现它所需的正确库
    • 例如：您使用 #include "bar.h"，但没有包含 "bar.h" 正常工作所需的 "foo.h"
  • 检查是否有与 'TYPE' 同名的函数

'CLASS_MEMBER' 在此上下文中是私有的

[edit | edit source]
  • 在 GCC 版本 3.2.3、4.5.1 中找到的消息
  • 通常以以下格式报告
    • (LOCATION_OF_PRIVATE_DATA_MEMBER) 错误：'DATA_MEMBER' 是私有的
    • (LOCATION_OF_CODE_ACCESSING_PRIVATE_DATA) 错误：在此上下文中
  • 错误信息通常是由于试图在类或结构的定义之外访问类或结构的私有数据成员而导致的
  • 确保友元成员函数名称没有拼写错误
class FooBar {
private: int bar;
public: friend void foo(FooBar & f);
};
void fooo(FooBar & f) {  // error
   f.bar = 0;
}
  • 确保只读函数为类使用 'const' 参数类型
  • 确保修改数据成员的函数不是常量
  • 检查派生类构造函数是否隐式访问基类的私有成员
class Foo {
private: Foo() {}
public: Foo(int Num) {}
};
class Bar : public Foo {
public: Bar() {}
// Bar() implicitly accesses Foo's private constructor
};
解决方案 1：使用初始化列表绕过隐式初始化
解决方案 2：将访问的基类成员设为受保护而不是私有
  • 您试图通过访问私有数据来初始化包含的类成员
class Foo {
private: char mrStr[5];
public: Foo(const char *s = "blah") { strcpy(mrStr, s); }
};

class Bar {
private:
   int mrNum;
   Foo aFoo;
public:
   Bar(int n, const Foo &f);
};

// error, attempting to use the Foo class constructor by accessing private data:
Bar::Bar(int n, const Foo &f) : aFoo(f.mrStr) {  // mrStr is private
   mrNum = n;
}

可能的解决方法是，为整个对象赋值，而不是部分赋值

Bar::Bar(int n, const Foo &f) : aFoo(f) {
   mrNum = n;
}

ISO C++ 禁止声明没有类型的 'FUNCTION'

[edit | edit source]
  • 在 GCC 3.2.3 和 4.5.1 版本中找到的错误信息
  • 您创建了一个没有列出返回值类型的函数
Foo() { return 0: }
// should be: int Foo() { return 0: }

多个定义

[edit | edit source]
例如：`main` 的多个定义
  • 在 GCC 版本 4.5.1 中找到的消息
  • 检查头文件中是否缺少包含守卫
  • 检查编译命令 / makefile 中是否有重复的文件列表
    • 例如：g++ -o foo foo.cpp foo.cpp
  • 检查头文件中是否仅有声明，而不是定义

'CLASS FUNCTION(ARGUMENTS)' 必须有一个类或枚举类型的参数

[edit | edit source]
  • 在 GCC 版本 3.2.3、4.5.1 中找到的消息
  • 您试图使用非成员函数访问类的成员
    • 非成员函数必须显式地访问类成员
例如：CLASS_NAME FUNCTION_NAME(CLASS_NAME OBJECT_NAME, ARGUMENTS)
  • 您正在为标准（内置）类型重新定义运算符
class Foo {
public:
   friend int operator+(int x, int y);
};

返回值类型中不能定义新类型

[edit | edit source]
  • 在 GCC 版本 4.5.1 中找到的消息
    • 在 GCC 3.2.3 版本中报告为
定义 'CLASS' 之后缺少分号
ISO C++ 禁止在返回值类型中定义类型
  • 检查类定义末尾是否缺少分号
class Foo {
public:
   int x;
}  // Error

没有匹配的 'FUNCTION' 调用

[edit | edit source]
  • 在 GCC 版本 3.2.3、4.5.1 中找到的消息
  • 确保使用了函数的命名空间 (using namespace std / std::function())
  • 确保函数名称没有拼写错误，括号没有遗漏
  • 确保函数调用使用了正确的参数 / 类型 / 类
  • 如果您使用括号初始化变量，如果变量名称中包含下划线，请尝试删除它们。有时等号是唯一可行的方式...
  • 您在同一个命名空间中为变量和函数使用了相同的名称
string bar() {
   string foo = "blah";
   return foo;
}

int main() {
   string bar;
   bar = bar();  // error, "bar()" was hidden by string initialization
   return 0;
}

没有匹配的 'FUNCTION' 调用

[编辑 | 编辑源代码]
  • 在 GCC 版本 4.5.1 中找到的消息
  • 确保没有在不应该出现的地方使用括号（例如：classname::value() 而不是 classname::value）。
  • 您正在使用字符串参数，而函数需要的是 C 字符串。
// broken code
ifstream in;
string MrString = "file.txt";
in.open(MrString);

// solution: convert the string to a C-string
ifstream in;
string MrString = "file.txt";
in.open(MrString.c_str());

非常量“VARIABLE”不能用作模板参数。

[编辑 | 编辑源代码]
  • 在 GCC 版本 3.2.3 中发现的消息。
    • 在 GCC 版本 4.5.1 中报告为：'VARIABLE' 不能出现在常量表达式中。
  • 变量用于模板参数，模板参数需要在编译时是常量。
template <class T, int num>
class Bar {
private:
   T Foo[num];
};

int main() {
   int woz = 8;
   Bar<double, woz> Zed;  // error, woz is not a constant
   return 0;
}

非成员函数 'FUNCTION' 不能有 cv 限定符。

[编辑 | 编辑源代码]
错误：非成员函数“int Foo()”不能有 cv 限定符。
cv = 常量 / 易变。
  • 在 GCC 版本 4.5.1 中找到的消息
  • 您正在对非成员函数使用“后置”常量（常量值）。
  • 您没有在函数定义中使用作用域限定符（“TYPENAME::”）。
  • 您为模板类的成员函数的定义拼错了。
template<class Type>
class Foo {
private:
   int stuff;
public:
   int bar() const;
};

template<class Type>
int Foo::bar() const {  // error
   return stuff;
}

可能的解决办法。

template<class Type>
int Foo<Type>::bar() const {
   return stuff;
}

将 'const OBJECT' 作为 'FUNCTION' 的 'this' 参数传递会丢弃限定符。

[编辑 | 编辑源代码]
  • 在 GCC 版本 4.5.1 中找到的消息
  • 您正在返回一个地址。
  • 您正在尝试使用 const_iterator 访问容器元素，但使用的是没有非 const 版本的成员函数。非 const 函数不保证它不会更改数据。

请求在“NAME”中使用成员“NAME”，而“NAME”是非类类型“CLASS”。

[编辑 | 编辑源代码]
  • 在 GCC 4.5.1 版本中找到的错误信息
    • 在 GCC 版本 3.2.3 中报告为
请求在“NAME”中使用成员“NAME”，而“NAME”是非聚合类型“TYPE”。
  • 检查代码中的函数调用，它可能正在调用带有错误参数的函数，或者可能放置或缺少括号。
  • 您正在使用“*this”指针，而您应该只使用函数名。
  • 例如，使用：return mem_func(); 而不是：return *this.mem_func();
  • 使用带有错误语法的“*this”指针。
class Foo {
public:
   int x;
   Foo(int num = 0) { x = num; }
   void newX(int num);
};

void Foo::newX(int num) {
   *this.newX(num);  // error, need (*this).newX or this->newX
}

语句无法解析重载函数的地址。

[编辑 | 编辑源代码]
  • 在 GCC 版本 3.2.3、4.5.1 中找到的消息
  • 确保您没有忘记成员函数名后面的括号。
class Foo {
public:
   int Bar() { return 0; }
};

int main() {
   Foo x;
   x.Bar;  // error
   return 0;
}

在 'NAME' 的声明中存在两个或多个数据类型。

[编辑 | 编辑源代码]
  • 在 GCC 版本 4.5.1 中找到的消息
    • 在 GCC 版本 3.2.3 中报告为：多余的 'TYPE' 被忽略。
  • 您为函数声明的返回值列出了多个数据类型。
int char sum(int x, int y);  // int char
  • 可能是两个类型声明之间缺少分号。
    • 通常在函数、结构体或类声明之后的花括号 {} 之后缺少。

<GOBBLEDEGOOK> 未定义对 <GOBBLEDEGOOK> 的引用。

[编辑 | 编辑源代码]
  • 在 GCC 版本 4.5.1 中找到的消息
    • 在 GCC 版本 4.0.1、4.2.1 中报告为：未定义的符号。
  • 检查是否有丢失或拼错的标题文件包含。
  • 检查项目/make 文件中是否有丢失或拼错的文件/库。
  • 检查是否有丢失、拼错或未定义的函数或类构造函数。
// header file
void foo();
void bar();
void baz();

// implementation file, bar definition is missing
void foo() { cout << "foo\n"; }
void baz() { cout << "baz\n"; }
  • 检查函数声明是否与其定义不匹配。
  • 确保函数名不与现有标题文件中的函数名重叠。
  • 确保编译命令语法/makefile 结构正确（例如：g++ -o file.cc ... 等）。
  • 项目/makefile 中的任何文件中都没有定义 main() 函数。
    • 例如：未定义对 `WinMain@16` 的引用。

'NAME' 在此作用域中未声明。

[编辑 | 编辑源代码]
  • 在 GCC 版本 4.5.1 中找到的消息
    • 在 GCC 版本 3.2.3 中报告为：'FUNCTION' 未声明（此函数的首次使用）。
  • 查找拼错或更改的变量/函数/标题调用名称。
lonh wait;

// instead of:
long wait;
  • 确保包含了正确的标题文件和库文件。
    • 定义的变量可能需要包含它们使用的标题文件，这些标题文件需要包含在所有使用定义的变量的文件中。
取自"https://wikibooks.cn/w/index.php?title=GCC_Debugging/g%2B%2B/Errors&oldid=3678524"
华夏公益教科书