详解 C++ Undefined Behavior

已于 2022-03-15 13:02:45 修改
阅读量669 收藏 1
点赞数 1
文章标签： c++ 开发语言 代码规范 安全
于 2022-03-15 11:06:21 首次发布
原文链接：https://github.com/Qihoo360/safe-rules/blob/main/cpp-ub-list.md
版权

  Undefined Behavior，即未定义的行为，指程序不可预测的执行效果，一般由错误的代码实现引起。出于效率、兼容性等多方面原因，语言标准不便于定义错误程序的明确行为，而是将其统称为“未定义”的行为，可以是崩溃，也可以是非预期的任意表现，有些问题在编译器和执行环境的特殊处理下也可能不会造成实质性的危害，但不具备可移植性。

  《安全规则集合》 是一个研究代码质量和安全措施的项目，本文是其中一个附录，最新信息可参见原文《C++ 未定义行为成因列表》。

  本文梳理了 ISO/IEC 14882:2003 和 ISO/IEC 14882:2011 前 18 章可导致未定义行为的代码实现方式，后 12 章的主题为标准库实现，相关内容的主旨在前 18 章中已有体现。C 语言相关内容可参见《C 未定义行为成因列表》。


目录

IDCircumstance
1代码行以反斜杠结尾，且与下一行连接后生成通用字符名称
2非空源文件未以换行符结尾，或以换行符结尾但换行符之前是反斜杠
3连接预处理符号时产生了通用字符名称
4存在不符合词法的单引号或双引号
5在 #include 指令中，’、"、\、//、/* 出现在定界符 < > 之间，或 '、\、//、/* 出现在定界符 " 之间
6无后缀 10 进制整数字面常量超过 long int 取值范围
7使用非标准转义字符
8修改字符串字面常量
9窄字符串与宽字符串连接
10违反 One Definition Rule
11具有静态或线程存储期的对象在析构函数中调用 std::exit 函数
12函数内具有静态或线程存储期的对象已析构，之后该函数又被调用并引用到已析构的对象
13在对象析构之后使用对象
14指针指向长度为 0 的内存空间并被解引用
15内存回收函数抛出异常
16使用不匹配的方法分配回收资源
17使用已被释放的指针
18对象生命周期已结束，但未调用其有副作用的析构函数
19在分配空间后，生命周期开始前，或在生命周期结束后，回收空间前，通过指针访问对象
20在分配空间后，生命周期开始前，或在生命周期结束后，回收空间前，通过 glvalue 访问对象
21具有静态、线程或自动存储期和 non-trivial 析构函数的对象，其空间被非兼容类型的对象占据
22常量对象的空间或曾属于常量对象的空间被其他对象占据
23通过 glvalue 访问对象，但 glvalue 的类型不符合要求
24通过 glvalue 引用不相关类型的对象或未初始化的对象
25浮点类型转换产生的结果无法在相应的空间中表示
26浮点类型转为整数类型时，整数类型无法存储浮点类型的整数部分
27整数类型转为浮点类型时，浮点类型无法存储整数的值
28对同一对象产生多重无确定顺序的副作用
29表达式的结果在数学上没有定义
30被调用函数的语言链接性与该函数定义的语言链接性不符
31将非 POD 对象传入可变参数列表
32用 static_cast 将基类引用转为派生类引用，基类为虚基类，或引用的实际对象并非派生类对象
33用 static_cast 将基类指针转为派生类指针，基类为虚基类，或指向的实际对象并非派生类对象
34用 static_cast 将成员指针转为基类成员指针时，基类中没有相关成员
35函数指针被转为不兼容的类型并执行
36类型转换时去掉对象 const 属性并修改对象
37对不完整类型的对象取地址，但该对象的完整类型重载了 operator &
38new 运算符第一个数组维度的参数为负数
39用 delete 释放数组漏写中括号，用 delete 释放对象多写中括号，用 delete 释放非 new 表达式的结果
40被 delete 释放的对象或数组类型不符合要求
41用 delete 释放不完整类型的对象，但在对象完整类型声明中有 non-trivial 析构函数
42对象解引用成员指针时，对象的动态类型不包含成员指针引用的成员
43对象解引用成员指针时，成员指针为空指针
44/ 或 % 运算符第二个操作数的值为 0
45指针加减整数，结果超出了指针所在数组的地址范围
46不在同一数组中的指针相减
47移位运算符右操作数为负数或超过相关类型比特位的数量
48对有符号整数进行超出取值范围的左移运算
49将对象赋值给具有重叠区域的对象
50函数没有通过 return 语句返回明确的值，但函数返回值被使用
51递归地定义和初始化静态对象
52修改非 mutable 常量对象
53使用没有 volatile 限定的 glvalue 访问有 volatile 限定的对象
54具有 noreturn 属性的函数返回至调用方
55空指针解引用
56对象的实际类型与当前静态类型不相关，并调用其非静态成员函数
57在构造函数或析构函数中调用纯虚函数
58对象的实际类型与当前静态类型不相关，并调用其析构函数
59在对象生命周期结束后调用其析构函数
60基类对象构造完毕之前调用成员函数
61对成员或基类对象的不合理引用
62将对象指针转为其基类对象的指针时，基类对象尚未开始构造或已结束析构
63正在构造或析构的对象通过 . 或 -> 调用虚函数，而且该对象与当前构造或析构函数不属于同一个类或基类
64typeid 作用于正在构造或析构的对象，而且该对象与当前构造或析构函数不属于同一个类或基类
65dynamic_cast 作用于正在构造或析构的对象，而且该对象与当前构造或析构函数不属于同一个类或基类
66需要无限递归的模版实例化
67构造或析构函数在 function-try-block 的 handler 中访问非静态成员
68有返回值的函数在 function-try-block 的 handler 中没有正确返回
69在 #if、 #elif 的条件中，由宏展开产生了 defined 表达式，或 defined 表达式格式不正确
70#include 指令经宏展开后不满足标准格式
71宏的实参列表中出现预处理指令
72预处理运算符 # 的结果不是有效的字符串
73预处理运算符 ## 的结果不是有效的符号
74#line 指定的行号为 0 或大于规定值
75#line 指令不符合标准格式
76用 #define 定义或用 #undef 取消定义具有保留意义的名称
77供语言机制调用的函数不符合要求
78程序实现了应由标准库提供的功能
79未经许可，向 std 命名空间添加声明或定义
80对标准库，特化模板类成员函数，特化模板类成员模板函数，特化、偏特化成员类模版
81未经许可，向 posix 命名空间添加声明或定义
82声明或定义标准库保留名称
83编译器未提供标准头文件，但编译时引入了非标准同名头文件
84为标准库函数提供不符合要求的参数
85多线程调用标准库函数造成 data race
86违反标准库函数要求的前置条件，除非标准库函数声明了这种情况会抛出异常
87offsetof 用于非 standard layout 类型，或用于计算静态成员以及成员函数的偏移量
88可变参数列表省略号左侧的形式参数为函数、数组或引用
89longjmp 跳转使应被执行的析构函数未被执行


说明


1. 代码行以反斜杠结尾，且与下一行连接后生成通用字符名称


如果代码行以反斜杠结尾，预处理器会删除行尾的反斜杠和换行符，使其与下一行连接，如果连接后产生了以 \u 或 \U 开头的通用字符名称（universal character name）会导致未定义的行为。

示例：

auto s = "\u54\
0D";               // Undefined behavior

auto \u54\
0D = 'a';          // Undefined behavior

例中字符串和变量名与下一行连接后产生了通用字符名称。

这种代码和预处理过程存在矛盾，可能不会通过编译，也可能不会造成实际问题，但一定不具备可移植性。



依据

ISO/IEC 14882:2003 2.1(2)-undefined
ISO/IEC 14882:2011 2.2(2)-undefined

规则

ID_badBackslash



2. 非空源文件未以换行符结尾，或以换行符结尾但换行符之前是反斜杠


示例：

namespace NS {
    ....
}\                 // Undefined behavior if this is the last line

这种代码在 C++03 中的行为是未定义的，C++11 规定在这种情况下编译器应补全所需的空行。



依据

ISO/IEC 14882:2003 2.1(2)-undefined

规则

ID_missingNewLineFileEnd
ID_badBackslash



3. 连接预处理符号时产生了通用字符名称


预处理运算符 ## 可以将两个符号连接成一个符号，如果产生了以 \u 或 \U 开头的通用字符名称会导致未定义的行为。

示例：

#define M(a, b) a ## b

int M(\u54, 0d) = 123;    // Undefined behavior


依据

ISO/IEC 14882:2003 2.1(4)-undefined
ISO/IEC 14882:2011 2.2(4)-undefined



4. 存在不符合词法的单引号或双引号


预处理器连接以反斜杠结尾的各行代码后将其转为预处理符号序列，在处理指令和展开宏之前，如果出现了不符合词法的单引号或双引号，会导致未定义的行为。

示例：

#defined X  '     // Undefined behavior
#defined Y  "     // Undefined behavior

例中的引号无法与其他字符组成预处理符号，可能不会通过编译，也可能产生非预期的结果。



依据

ISO/IEC 14882:2003 2.4(2)-undefined
ISO/IEC 14882:2011 2.5(2)-undefined



5. 在 #include 指令中，’、"、\、//、/* 出现在定界符 < > 之间，或 '、\、//、/* 出现在定界符 " 之间


示例：

#include <"foo">        // Undefined behavior in C++03
#include "foo//bar"     // Undefined behavior in C++03

C++03 声明了这些情况会导致未定义的行为，在 C++11 中则由实现定义。



依据

ISO/IEC 14882:2003 2.8(2)-undefined
ISO/IEC 14882:2011 2.9(2)-implementation

规则

ID_nonStandardCharInHeaderName



6. 无后缀 10 进制整数字面常量超过 long int 取值范围


示例：

cout << 2147483648;   // Undefined behavior in C++03

设 long int 为 32 位有符号整数类型，字面常量 2147483648 超出了范围，其行为在 C++03 中是未定义的，在 C++11 中则会将 2147483648 归为 unsigned long int 类型。



依据

ISO/IEC 14882:2003 2.13.1(2)-undefined



7. 使用非标准转义字符


标准转义字符：

\a          // Alert
\b          // Backspace
\f          // Formfeed page break
\n          // New line
\r          // Carriage return
\t          // Horizontal tab
\v          // Vertical tab
\\          // Backslash
\?          // Question mark
\'          // Single quotation mark
\"          // Double quotation mark
\0          // Null character
\ddd        // Any character, ‘d’ is an octal number
\xhh        // Any character, ‘h’ is a hex number

反斜杠后如果出现其他形式的字符或字符序列会导致未定义的行为。



依据

ISO/IEC 14882:2003 2.13.2(3)-undefined
ISO/IEC 14882:2011 2.14.3(3)-implementation

规则

ID_literal_nonStandardEsc



8. 修改字符串字面常量


示例：

*((char*)"oops") = 'O';   // Undefined behaivor, may crash
cout << "oops";           // If it doesn't crash, this might output ‘Oops’

修改字面常量是一种逻辑错误。多数通用系统会在运行时保护常量数据，相关修改会造成崩溃，在没有这种保护机制的系统中，字符串常量可能会被修改，但也可能会影响到其他相同的字符串常量，因为相同的字符串常量可能共用相同的存储空间。



依据

ISO/IEC 14882:2003 2.13.4(2)-undefined
ISO/IEC 14882:2011 2.14.5(12)-undefined

规则

ID_missingConst



9. 窄字符串与宽字符串连接


示例：

auto* x = L"123" "456";    // Undefined in C++03
auto* y = L"123" "456";    // A wide string in C++11


依据

ISO/IEC 14882:2003 2.13.4(3)-undefined
ISO/IEC 14882:2011 2.14.5(13)-implementation

规则

ID_literal_hybridConcat



10. 违反 One Definition Rule


任何翻译单元不得包含变量、函数、类型、枚举或模板的多个定义，即 One Definition Rule，违反此规则会导致未定义的行为。

示例：

// In a.cpp 
struct T {
    int i;
};

// In b.cpp 
struct T {
    long i;    // Undefined behavior, volates One Definition Rule
};


依据

ISO/IEC 14882:2003 3.2(5)-undefined
ISO/IEC 14882:2011 3.2(5)-undefined



11. 具有静态或线程存储期的对象在析构函数中调用 std::exit 函数


程序调用 exit 函数后，全局、静态或 thread_local 对象开始析构，而这种对象的析构函数再调用 exit 会导致未定义的行为。

示例：

class T {
    ....
public:
   ~T() {
        std::exit(1);  // Dangerous
    }
};

static T obj;  // Undefined behavior during destruct

例中 obj 对象在析构时会导致未定义的行为。



依据

ISO/IEC 14882:2003 3.6.1(4)-undefined
ISO/IEC 14882:2011 3.6.1(4)-undefined

规则

ID_exitCallInDestructor



12. 函数内具有静态或线程存储期的对象已析构，之后该函数又被调用并引用到已析构的对象


示例：

// In T.cpp
void foo() {
    static T sObj;
    ....
}

// In U.cpp
class U {
    ....
public:
   ~U() {
        foo();   // Undefined behavior if ‘sObj’ is destructed
    }
};

U gObj;   // Problematic

当例中全局对象 gObj 析构时会调用 foo 函数，如果这时 foo 函数中的局部静态对象 sObj 已析构，会导致未定义的行为，gObj 与 sObj 的析构顺序在标准中是不确定的。



依据

ISO/IEC 14882:2003 3.6.3(2)-undefined
ISO/IEC 14882:2011 3.6.3(2)-undefined



13. 在对象析构之后使用对象


示例：

extern T obj;

void foo() {
    obj.fun();   // Undefined behavior if ‘obj’ is destructed
}

当全局对象 obj 析构之后，再调用 foo 函数会导致未定义的行为（如在另一个全局对象的析构函数中调用 foo 函数）。



依据

ISO/IEC 14882:2011 3.6.3(4)-undefined

规则

ID_danglingDeref



14. 指针指向长度为 0 的内存空间并被解引用


示例：

void foo(size_t n) {
    int* p = new int[n];
    ....
    *p = 123;   // Undefined behavior if ‘n’ is zero
    ....
    delete[] p;
}

如果例中参数 n 为 0，对 p 的解引用会导致未定义的行为。



依据

ISO/IEC 14882:2003 3.7.3.1(2)-undefined
ISO/IEC 14882:2011 3.7.4.1(2)-undefined

规则

ID_arrayIndexOverflow



15. 内存回收函数抛出异常


示例：

class A {
    ....
public:
    void operator delete(void* p) {
        if (!p) {
            throw Exception();    // Undefined behavior
        }
        ....
    }
};

在 delete 运算符中抛出异常会导致未定义的行为。



依据

ISO/IEC 14882:2011 3.7.4.2(3)-undefined

规则

ID_throwInDelete



16. 使用不匹配的方法分配回收资源


示例：

T* p = new T;
....
free(p);   // Undefined behavior

例中用 free 释放由 new 分配的内存空间，会导致未定义的行为。



依据

ISO/IEC 14882:2011 3.7.4.2(3)-undefined

规则

ID_incompatibleDealloc



17. 使用已被释放的指针


示例：

int* p = new int(1);

delete p;      // Well-defined
delete p;      // Undefined behavior
cout << *p;    // Undefined behavior

指针指向的对象被回收后，指针的值和指针曾指向的对象均失败，继续访问会导致未定义的行为。



依据

ISO/IEC 14882:2003 3.7.3.2(4)-undefined
ISO/IEC 14882:2011 3.7.4.2(4)-undefined

规则

ID_illAccess
ID_doubleFree
ID_danglingDeref



18. 对象生命周期已结束，但未调用其有副作用的析构函数


示例：

struct U {
    ....
};

struct T {
   ~T();    // If it has side effects
    ....
};

void* p = malloc(max(sizeof(T), sizeof(U)));
T* pT = new (p) T;
U* pU = new (p) U;     // Undefined behavior

例中第二个 new 表达式结束了 pT 所指对象的生命周期，但没有调用其析构函数，如果其析构函数存在副作用，则会导致未定义的行为，可能会造成资源泄露或逻辑错误。



依据

ISO/IEC 14882:2003 3.8(4)-undefined
ISO/IEC 14882:2011 3.8(4)-undefined



19. 在分配空间后，生命周期开始前，或在生命周期结束后，回收空间前，通过指针访问对象


在对象的生命周期之外，通过指针进行如下操作会导致未定义的行为：

  • 访问非静态成员函数
  • 将指针转为基类指针
  • 用 static_cast 转换指针（转为 void*、char*、unsigned char* 等情况除外）
  • 用 dynamic_cast 转换指针

示例：

struct T {
    T();
   ~T();
    void fun();
};

T* p = (T*)malloc(sizeof(T));
p->fun();   // Undefined behavior

new (p) T();
p->fun();   // Well-defined

p->~T();
p->fun();   // Undefined behavior

free(p);


依据

ISO/IEC 14882:2003 3.8(5)-undefined
ISO/IEC 14882:2011 3.8(5)-undefined



20. 在分配空间后，生命周期开始前，或在生命周期结束后，回收空间前，通过 glvalue 访问对象


在对象的生命周期之外，通过 glvalue 进行如下操作会导致未定义的行为：

  • 进行 lvalue-to-rvalue 转换
  • 访问非静态成员函数
  • 向基类引用转换
  • 用 static_cast 转换 glvalue（转为 char& 或 unsigned char& 等情况除外）
  • 用 dynamic_cast 转换 glvalue
  • 将 typeid 作用于 glvalue

示例：

struct B { void foo(); };
struct D: B { .... };

void B::foo() {
    new (this) D;    // Ends the lifetime of *this
}

void bar(B& b) {
    b.foo();
    if (typeid(b) == ....) {   // Undefined behavior
        ....
    }
}

例中 b.foo 执行后 b 的生命周期结束，之后再对 b 的访问会导致未定义的行为。



依据

ISO/IEC 14882:2003 3.8(6)-undefined
ISO/IEC 14882:2011 3.8(6)-undefined



21. 具有静态、线程或自动存储期和 non-trivial 析构函数的对象，其空间被非兼容类型的对象占据


示例：

struct A { ~A(); };
struct B { ~B(); };

void foo() {
    A a;
    new (&a) B;
}   // Undefined behavior

例中局部对象 a 的空间被不相关类型的对象占据，在 foo 函数返回前仍会调用 A 的析构函数，导致未定义的行为。



依据

ISO/IEC 14882:2003 3.8(8)-undefined
ISO/IEC 14882:2011 3.8(8)-undefined



22. 常量对象的空间或曾属于常量对象的空间被其他对象占据


示例：

struct T {
    T();
   ~T();
};

const T obj;

void foo() {
    obj.~T();
    new (&obj) const T;   // Undefined behavior
}


依据

ISO/IEC 14882:2003 3.8(9)-undefined
ISO/IEC 14882:2011 3.8(9)-undefined



23. 通过 glvalue 访问对象，但 glvalue 的类型不符合要求


只应通过以下类型的 glvalue 访问对象，否则导致未定义的行为：

  • 对象的动态类型
  • 用 const 或 volatile 限定的对象动态类型
  • 与对象动态类型相似的类型（参见 ISO/IEC 14882:2011 4.4）
  • 与对象动态类型对应的有符号或无符号类型
  • 用 const 或 volatile 限定的与对象动态类型对应的有符号或无符号类型
  • 包含上述类型的聚合或联合类型（不包括静态成员类型）
  • 对象动态类型的基类类型（也包括被 const 或 volatile 限定的基类类型）
  • char 或 unsigned char

示例：

int i = 0;

cout << i;                 // Well-defined
cout << (const int&)i;     // Well-defined
cout << (unsigned int&)i;  // Well-defined
cout << (char&)i;          // Well-defined

cout << (long&)i;          // Undefined behavior
cout << (float&&)i;        // Undefined behavior


依据

ISO/IEC 14882:2003 3.10(15)-undefined
ISO/IEC 14882:2011 3.10(10)-undefined



24. 通过 glvalue 引用不相关类型的对象或未初始化的对象


glvalue 的类型与其引用的对象类型不同且没有继承关系，以及引用的对象未初始化，会导致未定义的行为。

示例：

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

int foo(A& a) {
    return ((B&)a).i;   // Undefined behavior, unrelated type conversion
}

int foo() {
    int i;
    return i;   // Undefined behavior, ‘i’ is not initialized
}


依据

ISO/IEC 14882:2003 4.1(1)-undefined
ISO/IEC 14882:2011 4.1(1)-undefined

规则

ID_castNoInheritance
ID_localInitialization



25. 浮点类型转换产生的结果无法在相应的空间中表示




依据

ISO/IEC 14882:2003 4.8(1)-undefined
ISO/IEC 14882:2011 4.8(1)-undefined



26. 浮点类型转为整数类型时，整数类型无法存储浮点类型的整数部分


示例：

double f = 1e60;
signed i = f;      // Undefined behavior

例中 1e60 无法被整型变量存储，导致未定义的行为。



依据

ISO/IEC 14882:2003 4.9(1)-undefined
ISO/IEC 14882:2011 4.9(1)-undefined

规则

ID_narrowCast



27. 整数类型转为浮点类型时，浮点类型无法存储整数的值


示例：

long n = 1234567890L;
float f0 = n;            // Cannot be represented exactly
double f1 = n;           // OK

例中 1234567890 无法被 float 变量存储，但可被 double 变量存储。



依据

ISO/IEC 14882:2011 4.9(2)-undefined

规则

ID_narrowCast



28. 对同一对象产生多重无确定顺序的副作用


示例：

volatile int* p = foo();
int n = *p + *p;          // Undefined behavior

例中 n 的值在数学上应是 *p 的二倍，但由于 p 指向 volatile 数据，结果可能不符合预期的数学关系。



依据

ISO/IEC 14882:2003 5(4)-undefined

规则

ID_evaluationOrderReliance
ID_confusingAssignment



29. 表达式的结果在数学上没有定义


如除 0、有符号整数溢出、负数位运算、浮点异常等均会导致未定义的行为。

示例：

signed s = INT_MAX + 1;     // Undefined
unsigned u = UINT_MAX + 1;  // Well-defined

例中变量 u 的值一定是 0，而 s 的值是标准未定义的，往往由编译器和执行环境决定。

无符号整数运算在程序中的结果是数学上的结果与 (M + 1) 取模的结果，M 是其类型对应的最大值，在数学上有明确定义，而对于有符号整数，将符号位移出相关比特位，或将非符号位移入符号位，在数学上是没有意义的，故称无符号整数不存在溢出问题，有符号整数存在溢出问题，溢出会导致未定义的行为。



依据

ISO/IEC 14882:2003 5(5)-undefined
ISO/IEC 14882:2011 5(4)-undefined

规则

ID_evalOverflow



30. 被调用函数的语言链接性与该函数定义的语言链接性不符


示例：

// In a.c
int foo() {
    return 0;
}

// In b.cpp
int foo();          // Missing extern "C"

int bar() {
    return foo();   // Undefined behavior
}


依据

ISO/IEC 14882:2003 5.2.2(1)-undefined
ISO/IEC 14882:2011 5.2.2(1)-undefined



31. 将非 POD 对象传入可变参数列表


可变参数列表是 C 语言的概念，C++ 中具有拷贝构造或析构函数的对象难以与其兼容，将非 POD 对象传入可变参数列表在 C++03 中是未定义的，在 C++11 中是部分由实现定义的。

示例：

string str;
void foo(int, ...);

foo(1, str);         // Undefined behavior

例中 string 类对象 str 是非 POD 对象，由于其特殊的拷贝构造过程，在 foo 函数中通过 va_arg 难以获取正确的对象。



依据

ISO/IEC 14882:2003 5.2.2(7)-undefined
ISO/IEC 14882:2011 5.2.2(7)-implementation

规则

ID_userObjectAsVariadicArgument
ID_forbidVariadicFunction



32. 用 static_cast 将基类引用转为派生类引用，基类为虚基类，或引用的实际对象并非派生类对象


示例：

struct A {};
struct B: A {};
struct C: virtual B {};

A a;
C c;
A& ra = a;
A& rc = c;

static_cast<B&>(ra);    // Undefined behavior
static_cast<C&>(rc);    // Undefined behavior

例中 ra 引用的是基类对象，将其转为派生类引用会导致未定义的行为，A 和 B 是 C 的虚基类，需要运行时数据体现虚基类对象和派生类对象的空间关系，static_cast 不考虑与运行时相关的转换逻辑，无法正确转换。



依据

ISO/IEC 14882:2003 5.2.9(5)-undefined
ISO/IEC 14882:2011 5.2.9(2)-undefined

规则

ID_downCast



33. 用 static_cast 将基类指针转为派生类指针，基类为虚基类，或指向的实际对象并非派生类对象


示例：

struct A {};
struct B: A {};
struct C: virtual B {};

A a;
C c;
A* pa = &a;
A* pc = &c;

static_cast<B*>(pa);    // Undefined behavior
static_cast<C*>(pc);    // Undefined behavior

例中 pa 指向基类对象，将其转为派生类指针会导致未定义的行为，A 和 B 是 C 的虚基类，需要运行时数据体现虚基类对象和派生类对象的空间关系，static_cast 不考虑与运行时相关的转换逻辑，无法正确转换。



依据

ISO/IEC 14882:2003 5.2.9(8)-undefined
ISO/IEC 14882:2011 5.2.9(11)-undefined

规则

ID_downCast



34. 用 static_cast 将成员指针转为基类成员指针时，基类中没有相关成员


示例：

struct B { int b; };
struct D: B { int d; };

int D::* mpb = &D::b;
int D::* mpd = &D::d;

static_cast<int B::*>(mpb);    // OK
static_cast<int B::*>(mpd);    // Undefined behavior

例中基类没有成员 d，将指向成员 d 的成员指针转为基类成员指针会导致未定义的行为。



依据

ISO/IEC 14882:2003 5.2.9(9)-undefined
ISO/IEC 14882:2011 5.2.9(12)-undefined

规则

ID_downCast



35. 函数指针被转为不兼容的类型并执行


示例：

void foo();

return ((int(*)())(&foo))();  // Undefined behavior

例中 foo 函数没有返回值，将其强转为有返回值的函数并调用，会导致未定义的行为。



依据

ISO/IEC 14882:2003 5.2.10(6)-undefined
ISO/IEC 14882:2011 5.2.10(6)-undefined

规则

ID_functionPointerCast



36. 类型转换时去掉对象 const 属性并修改对象


示例：

const int ci = 0;
const_cast<int&>(ci) = 1;  // Undefined behavior


依据

ISO/IEC 14882:2003 5.2.11(7)-undefined
ISO/IEC 14882:2011 5.2.11(7)-undefined

规则

ID_qualifierCastedAway



37. 对不完整类型的对象取地址，但该对象的完整类型重载了 operator &


示例：

struct T;             // Incomplete type

T* foo(T& obj) {
    return &obj;      // Undefined behaviour
}

struct T {
    T* operator &();  // Overload
};


依据

ISO/IEC 14882:2003 5.3.1(4)-undefined
ISO/IEC 14882:2011 5.3.1(5)-undefined

规则

ID_overloadAddressOperator



38. new 运算符第一个数组维度的参数为负数


示例：

int* foo(int n) {
    return new int[n];   // Undefined in C++03 if ‘n’ is negtive
}

例中 n 如果为负数，其行为在 C++03 中是未定义的，C++11 去掉了这项未定义行为的声明。



依据

ISO/IEC 14882:2003 5.3.4(6)-undefined



39. 用 delete 释放数组漏写中括号，用 delete 释放对象多写中括号，用 delete 释放非 new 表达式的结果


示例：

string object;

delete &object;       // Undefined behavior
delete "string";      // Undefined behavior
delete new int[n];    // Undefined behavior
delete[] new int(n);  // Undefined behavior


依据

ISO/IEC 14882:2003 5.3.5(2)-undefined
ISO/IEC 14882:2011 5.3.5(2)-undefined

规则

ID_excessiveDelete
ID_insufficientDelete
ID_incompatibleDealloc
ID_illDealloc



40. 被 delete 释放的对象或数组类型不符合要求


用 delete 释放对象时，对象的静态类型应与动态类型兼容，如果静态类型是动态类型的基类，静态类型应提供虚析构函数，否则导致未定义的行为；用 delete[] 释放数组时，对象的静态类型应与动态类型一致，否则导致未定义的行为。

示例：

struct B { ~B(); };
struct D: B { ~D(); };

B* pDObj = new D;
B* pDArr = new D[123];

delete pDObj;      // Undefined behavior
delete[] pDArr;    // Undefined behavior

例中基类 B 缺少虚析构函数，pDArr 的类型应为派生类指针。



依据

ISO/IEC 14882:2003 5.3.5(3)-undefined
ISO/IEC 14882:2011 5.3.5(3)-undefined

规则

ID_missingVirtualDestructor



41. 用 delete 释放不完整类型的对象，但在对象完整类型声明中有 non-trivial 析构函数


示例：

struct T;

void foo(T* p) {
    delete p;       // Undefined behavior
}

struct T {
   ~T();            // Non-trivial destructor
};

例中 delete 作用于不完整类型的指针 p，会导致未定义的行为。



依据

ISO/IEC 14882:2003 5.3.5(5)-undefined
ISO/IEC 14882:2011 5.3.5(5)-undefined

规则

ID_deleteIncompleteType



42. 对象解引用成员指针时，对象的动态类型不包含成员指针引用的成员


示例：

struct A { int a; };
struct B { int a, b; };

int foo(A* pa) {
    B* pb = (B*)pa;
    int B::* m = &B::b;
    return pb->*m;         // Undefined behavior
}


依据

ISO/IEC 14882:2003 5.5(4)-undefined
ISO/IEC 14882:2011 5.5(4)-undefined



43. 对象解引用成员指针时，成员指针为空指针


示例：

struct T { .... };

int foo(T& obj) {
    int T::* mp = nullptr;
    return obj.*mp;          // Undefined behavior
}


依据

ISO/IEC 14882:2003 5.5(6)-undefined
ISO/IEC 14882:2011 5.5(6)-undefined



44. / 或 % 运算符第二个操作数的值为 0


示例：

int foo(int a, int b) try
{
    return a / b;   // Undefined behavior if ‘b’ is zero
}
catch (...)
{
    return 0;       // Unreachable
}

除数为 0 会导致未定义的行为，且不受语言的异常机制控制。



依据

ISO/IEC 14882:2003 5.6(4)-undefined
ISO/IEC 14882:2011 5.6(4)-undefined

规则

ID_divideByZero



45. 指针加减整数，结果超出了指针所在数组的地址范围


示例：

int foo() {
    int a[10];
    ....
    int* p = a + 9;   // OK
    return p[1];      // Undefined behavior
}

例中 p[1] 相当于 *(p + 1)，即 a[10]，超过了数组最后一个元素的地址，导致未定义的行为。



依据

ISO/IEC 14882:2003 5.7(5)-undefined
ISO/IEC 14882:2011 5.7(5)-undefined

规则

ID_bufferOverflow
ID_arrayIndexOverflow



46. 不在同一数组中的指针相减


示例：

int a[10];
int b[10];
ptrdiff_t d = a - b;  // Undefined behavior


依据

ISO/IEC 14882:2003 5.7(5)-undefined
ISO/IEC 14882:2011 5.7(5)-undefined

规则

ID_illPtrDiff



47. 移位运算符右操作数为负数或超过相关类型比特位的数量


示例：

int a = 1 << -1;    // Undefined behavior
int b = 1 << 100;   // Undefined behavior


依据

ISO/IEC 14882:2003 5.8(1)-undefined
ISO/IEC 14882:2011 5.8(1)-undefined

规则

ID_illShiftCount



48. 对有符号整数进行超出取值范围的左移运算


将符号位移出相关比特位，或将非符号位移入符号位，在数学上是没有意义的。

示例：

int b = -1 << 1;    // Undefined

编译器可能会用乘法或除法实现有符号整数的移位，但不属于标准行为。



依据

ISO/IEC 14882:2011 5.8(2)-undefined

规则

ID_bitwiseOperOnSigned



49. 将对象赋值给具有重叠区域的对象


示例：

struct T {
    int a[10];
};

struct W {
    int i;
    T t;
};

union U {
    T t;
    W w;
};

void foo(U& u) {
    u.w.t = u.t;    // Undefined behavior
}

例中 u.w.t 和 u.t 具有部分重叠区域，导致未定义的行为。



依据

ISO/IEC 14882:2003 5.17(8)-undefined
ISO/IEC 14882:2011 5.17(8)-undefined



50. 函数没有通过 return 语句返回明确的值，但函数返回值被使用


示例：

bool foo(int i) {
    if (i > 10) {
        return true;
    }
}   // Undefined behavior if i <= 10

如果例中 i 的值小于或等于 10，函数将返回一个不确定的值，使用这种不确定的值会导致未定义的行为。



依据

ISO/IEC 14882:2003 6.6.3(2)-undefined
ISO/IEC 14882:2011 6.6.3(2)-undefined

规则

ID_notAllBranchReturn



51. 递归地定义和初始化静态对象


示例：

int foo(int i) {
    if (i < 100) {
        static int s = foo(2 * i);   // Undefined behavior
        return s;
    }
    return i;
}

例中静态局部变量 s 的初始化需要递归调用所属函数，是否会产生多个 s 的实例以及是否能正常结束递归，均是未定义的。



依据

ISO/IEC 14882:2003 6.7(4)-undefined
ISO/IEC 14882:2011 6.7(4)-undefined



52. 修改非 mutable 常量对象


示例：

struct T {
    mutable int i;
    int j;
};

const T obj;
obj.i++;            // Well-defined
obj.j++;            // Ill-formed

T* p = (T*)&obj;
p->i = 0;           // Well-defined
p->j = 1;           // Undefined behavior


依据

ISO/IEC 14882:2003 7.1.5.1(4)-undefined
ISO/IEC 14882:2011 7.1.6.1(4)-undefined

规则

ID_qualifierCastedAway



53. 使用没有 volatile 限定的 glvalue 访问有 volatile 限定的对象


示例：

int foo(int&);
volatile int* bar();

foo((int&)*bar());   // Undefined behavior


依据

ISO/IEC 14882:2003 7.1.5.1(7)-undefined
ISO/IEC 14882:2011 7.1.6.1(6)-undefined

规则

ID_qualifierCastedAway



54. 具有 noreturn 属性的函数返回至调用方


示例：

[[noreturn]] void foo() {
    throw Exception();          // OK
}

[[noreturn]] int bar() {
    return 0;                   // Undefined behavior
}

[[noreturn]] void baz(int i) {  // Undefined behavior if ‘i’ != 0
    if (i == 0) {
        throw Exception();
    }
}

例中 bar 可以正常返回，baz 在某条件下正常返回，会导致未定义的行为。



依据

ISO/IEC 14882:2011 7.6.3(2)-undefined

规则

ID_unsuitableReturn



55. 空指针解引用


空指针表示没有指向任何对象的指针，通过空指针访问对象属于逻辑错误。

示例：

struct T {
    int i;

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

    static int baz();
};

T* p = nullptr;

p->foo();   // Undefined behavior
p->bar();   // Undefined behavior
p->baz();   // Well-defined, ‘baz’ is a static member

例中通过空指针调用对象的非静态成员函数会导致未定义的行为，即使成员函数没有引用成员数据。通过空指针调用静态成员函数不属于访问对象，所以这种情况不属于逻辑错误。



依据

ISO/IEC 14882:2003 8.3.2(4)-undefined
ISO/IEC 14882:2011 8.3.2(5)-undefined

规则

ID_nullDerefInScp
ID_nullDerefInExp



56. 对象的实际类型与当前静态类型不相关，并调用其非静态成员函数


示例：

struct A { int foo(); };
struct B { .... };

int bar(void* p) {
    return ((A*)p)->foo();
}

int main() {
    B b;
    return bar(&b);  // Undefined behavior
}

例中 A 与 B 是不同且没有继承关系的类，通过不合理的类型转换调用非静态成员函数会导致未定义的行为。



依据

ISO/IEC 14882:2003 9.3.1(1)-undefined
ISO/IEC 14882:2011 9.3.1(2)-undefined

规则

ID_castNoInheritance
ID_forbidMemberVoidPtr
ID_forbidFunctionVoidPtr



57. 在构造函数或析构函数中调用纯虚函数


示例：

struct T {
    virtual ~T() {
        release();   // Undefined behavior
    }

    virtual void release() = 0;
};


依据

ISO/IEC 14882:2003 10.4(6)-undefined
ISO/IEC 14882:2011 10.4(6)-undefined

规则

ID_virtualCallInConstructor
ID_virtualCallInDestuctor



58. 对象的实际类型与当前静态类型不相关，并调用其析构函数


示例：

void foo(void* p) {
    delete (T*)p;      // Undefined if delete an object of type other than T
}

如果例中 p 指向的不是 T 类型的对象会导致未定义的行为。



依据

ISO/IEC 14882:2003 12.4(12)-undefined
ISO/IEC 14882:2011 12.4(13)-undefined

规则

ID_forbidFunctionVoidPtr
ID_forbidMemberVoidPtr
ID_castNoInheritance



59. 在对象生命周期结束后调用其析构函数


示例：

struct T { ~T(); };

void foo() {
    T obj;
    obj.~T();  // End of lifetime
}              // Undefined behavior

显式调用 obj 的析构函数后，obj 的生命周期结束，但函数返回前还会调用 obj 的析构函数，导致未定义的行为。

又如：

struct B { .... };
struct D: B { .... };

D* p = new D;
p->B::~B();    // End of lifetime of base class object
delete p;      // Undefined behavior

调用 p->B::~B() 后，基类对象的生命周期结束，但在 delete p 时基类析构函数仍会被执行，导致未定义的行为。



依据

ISO/IEC 14882:2003 12.4(14)-undefined
ISO/IEC 14882:2011 12.4(15)-undefined

规则

ID_explicitDtorCall



60. 基类对象构造完毕之前调用成员函数


示例：

struct A {
    A(int);
};

struct B: A {
    int i;
    int fun();

    B(): A(fun()),     // Undefined
         i(fun()) {    // Well-defined
    }   
};

例中成员函数 fun 的返回值是基类构造函数的参数，但基类尚未开始构造，会导致未定义的行为，用成员函数 fun 初始化成员 i 则没有问题，因为此时基类对象已构造完毕。



依据

ISO/IEC 14882:2003 12.6.2(8)-undefined
ISO/IEC 14882:2011 12.6.2(13)-undefined

规则

ID_illMemberCall



61. 对成员或基类对象的不合理引用


对具有 non-trivial 构造函数的对象，在构造函数执行之前引用其非静态成员或基类对象，或者在析构函数执行之后引用其非静态成员或基类对象，会导致未定义的行为。

示例：

struct A {              // Trivial
    int a;
};

struct B: A {           // Non-trivial
    B();
    int b;
};

extern B obj;           // The object is defined later
B* p = &obj;            // OK
int* p1 = &obj.a;       // Undefined, refers to base class member
int* p2 = &obj.b;       // Undefined, refers to member

A* pa = &obj;           // Undefined, upcast to a base class type

extern A trvlObj;       // The object is defined later
int* p3 = &trvlObj.a;   // OK, A is a trivial class

B obj;                  // Define the object
A trvlObj;              // Define the object


依据

ISO/IEC 14882:2003 12.7(1)-undefined
ISO/IEC 14882:2011 12.7(1)-undefined



62. 将对象指针转为其基类对象的指针时，基类对象尚未开始构造或已结束析构


示例：

struct A {
    ....
};

struct B: A {
    B();
    B(A*);
};

struct C: B {
    C(): B(this) {     // Undefined behavior
    }
};

例中将 C 的 this 指针作为基类 B 构造函数的参数，相当于将 C* 转为 A*，而这时基类 B 和 A 均未开始构造，会导致未定义的行为。

又如（各项声明接上例）：

struct X {
    X(A*);
};

struct D: B, X {
    D(): B(), X(this) {  // OK
    }
};

将 D 的 this 指针作为基类 X 构造函数的参数，相当于将 D* 转为 A*，这时 B 的构造函数已经执行完毕，所以这种情况没有问题。



依据

ISO/IEC 14882:2003 12.7(2)-undefined
ISO/IEC 14882:2011 12.7(3)-undefined



63. 正在构造或析构的对象通过 . 或 -> 调用虚函数，而且该对象与当前构造或析构函数不属于同一个类或基类


示例：

struct V {
    virtual void foo();
    virtual void bar();
};

struct A: virtual V {
    void foo() override;
};

struct B: virtual V {
    B(V*, A*);
    void bar() override;
};

struct C: A, B {
    C(): B((A*)this, this) {
    }
    void foo() override;
    void bar() override;
};

B::B(V* v, A* a) {
    v->bar();       // Well-defined, V is the base of B
    a->foo();       // Undefined behavior, A is not a base of B
}


依据

ISO/IEC 14882:2003 12.7(3)-undefined
ISO/IEC 14882:2011 12.7(4)-undefined



64. typeid 作用于正在构造或析构的对象，而且该对象与当前构造或析构函数不属于同一个类或基类


示例：

struct V {
    virtual void foo();
};

struct A: virtual V {};
struct B: virtual V { B(V*, A*); };

struct C: A, B {
    C(): B((A*)this, this) {}
};

B::B(V* v, A* a) {
    typeid(*v);        // Well-defined, V is the base of B
    typeid(*a);        // Undefined behavior, A is not a base of B
}


依据

ISO/IEC 14882:2003 12.7(4)-undefined
ISO/IEC 14882:2011 12.7(5)-undefined



65. dynamic_cast 作用于正在构造或析构的对象，而且该对象与当前构造或析构函数不属于同一个类或基类


示例：

struct V {
    virtual void foo();
};

struct A: virtual V {};
struct B: virtual V { B(V*, A*); };

struct C: A, B {
    C(): B((A*)this, this) {}
};

B::B(V* v, A* a) {
    dynamic_cast<B*>(v);    // Well-defined, V is the base of B
    dynamic_cast<B*>(a);    // Undefined behavior, A is not a base of B
}


依据

ISO/IEC 14882:2003 12.7(5)-undefined
ISO/IEC 14882:2011 12.7(6)-undefined



66. 需要无限递归的模版实例化


示例：

template <class T>
class A
{
    A<T>* p;   // OK
    A<T*> a;   // Undefined behavior
};

如果实例化 A，需要实例化 A<T*>，如果实例化 A<T*>，需要实例化 A<T**>，依次类推，形成了无限递归。



依据

ISO/IEC 14882:2003 14.7.1(14)-undefined
ISO/IEC 14882:2011 14.7.1(15)-undefined



67. 构造或析构函数在 function-try-block 的 handler 中访问非静态成员


示例：

class T {
    int err;

public:
    T() try { .... } catch (...) { log(err); }  // Undefined behavior
   ~T() try { .... } catch (...) { log(err); }  // Undefined behavior
};

流程进入 function-try-block 的 handler 时，非静态成员的生命周期已结束，不可再被访问。



依据

ISO/IEC 14882:2003 15.3(10)-undefined
ISO/IEC 14882:2011 15.2(10)-undefined

规则

ID_illMemberAccess



68. 有返回值的函数在 function-try-block 的 handler 中没有正确返回


示例：

int foo() try {    // Function-try-block
    return bar();
}
catch (...) {      // Undefined behavior if there is no return statement
}

例中 function-try-block 的 handler 没有 return 语句，捕获异常后会返回不确定的值。



依据

ISO/IEC 14882:2003 15.3(16)-undefined
ISO/IEC 14882:2011 15.3(15)-undefined

规则

ID_notAllBranchReturn



69. 在 #if、 #elif 的条件中，由宏展开产生了 defined 表达式，或 defined 表达式格式不正确


示例：

#define DEFINED(x) defined(x)

#if DEFINED(__cplusplus)   // Undefined behavior
....
#endif


依据

ISO/IEC 14882:2003 16.1(4)-undefined
ISO/IEC 14882:2011 16.1(4)-undefined

规则

ID_macro_defineReserved
ID_illFormedDirective



70. #include 指令经宏展开后不满足标准格式


示例：

#define STDIO_H <stdio.h>
#define STDLIB_H stdlib.h

#include STDIO_H        // OK
#include STDLIB_H       // Undefined behavior


依据

ISO/IEC 14882:2003 16.2(4)-undefined
ISO/IEC 14882:2011 16.2(4)-undefined

规则

ID_illFormedDirective



71. 宏的实参列表中出现预处理指令


示例：

#define PRINT(s) printf(#s)

PRINT(
#ifdef MAC      // Undefined behavior
    rabbit
#else
    hamster
#endif
);


依据

ISO/IEC 14882:2003 16.3(10)-undefined
ISO/IEC 14882:2011 16.3(11)-undefined

规则

ID_directiveInMacroArgument
ID_macro_function



72. 预处理运算符 # 的结果不是有效的字符串


示例：

#define M(x) #x

cout << M();      // Undefined behavior

例中宏 M 的参数不足，无法生成有效的字符串，这可能不会通过编译，也可能产生空串，或其他非预期的结果。



依据

ISO/IEC 14882:2003 16.3.2(2)-undefined
ISO/IEC 14882:2011 16.3.2(2)-undefined

规则

ID_macro_complexConcat



73. 预处理运算符 ## 的结果不是有效的符号


示例：

#define M(a, b)  a ## b

int M(x, 0) = 0;   // OK, ‘x0’ is a valid token
int M(0, x) = 0;   // Undefined behavior, ‘0x’ is not a valid token


依据

ISO/IEC 14882:2003 16.3.3(3)-undefined
ISO/IEC 14882:2011 16.3.3(3)-undefined

规则

ID_macro_complexConcat



74. #line 指定的行号为 0 或大于规定值


C++03 规定行号不可大于 32767，C++11 规定不可大于 2147483647

示例：

#line 0             // Undefined behavior
#line 2147483648    // Undefined behavior


依据

ISO/IEC 14882:2003 16.4(3)-undefined
ISO/IEC 14882:2011 16.4(3)-undefined

规则

ID_illFormedDirective



75. #line 指令不符合标准格式


#line 后只应为整数常量或整数常量和文件名称字符串，其他形式均会导致未定义的行为。

示例：

#line "name.cpp"        // Undefined behavior
#line NUM + 1234        // Undefined behavior


依据

ISO/IEC 14882:2003 16.4(5)-undefined
ISO/IEC 14882:2011 16.4(5)-undefined

规则

ID_illFormedDirective



76. 用 #define 定义或用 #undef 取消定义具有保留意义的名称


如 __LINE__、__FILE__、__DATE__、__TIME__、__STDC__、__cplusplus、defined 等名称被定义或取消定义。

示例：

#undef __cplusplus   // Undefined behavior
#define __STDC__ 0   // Undefined behavior


依据

ISO/IEC 14882:2003 16.8(3)-undefined
ISO/IEC 14882:2011 16.8(4)-undefined

规则

ID_macro_defineReserved
ID_macro_undefReserved



77. 供语言机制调用的函数不符合要求


如 replacement functions 或 handler functions 不符合要求（required behavior），会导致未定义的行为。

示例：

struct T {
    void* operator new(size_t) {  // A replacement function
        return nullptr;           // Undefined behavior
    }
};

标准要求 operator new 返回非空地址，分配失败则抛出 bad_alloc 异常（见 ISO/IEC 14882:2011 18.6.1.1），否则导致未定义的行为。

又如：

void my_handler() {  // A handler function
     return;         // Do nothing
}

int main() {
    set_terminate(my_handler);   // Undefined behavior
    ....
}

标准要求 terminate handler 结束进程的执行，不可返回至调用方（见 ISO/IEC 14882:2011 18.8.3.1），否则导致未定义的行为。



依据

ISO/IEC 14882:2003 17.1.15-undefined
ISO/IEC 14882:2011 17.3.21-undefined



78. 程序实现了应由标准库提供的功能


示例：

namespace std
{
    const int& max(const int& a, const int& b) {  // Undefined behavior
        ....
    }
}

示例代码实现的 max 会干扰标准库中的 max，导致未定义的行为。



依据

ISO/IEC 14882:2003 17.1.17-undefined
ISO/IEC 14882:2011 17.3.22-undefined



79. 未经许可，向 std 命名空间添加声明或定义


示例：

namespace std
{
    using tstring = basic_string<
        TCHAR, char_traits<TCHAR>, allocator<TCHAR>   // Undefined behavior
    >;
}

示例代码向标准库命名空间添加了声明，这种对特殊命名空间的修改是否会生效，以及是否会造成非预期的影响，均是未定义的。



依据

ISO/IEC 14882:2011 17.6.4.2.1(1)-undefined

规则

ID_stdNamespaceModified



80. 对标准库，特化模板类成员函数，特化模板类成员模板函数，特化、偏特化成员类模版


示例：

template <>
void std::vector<int>::push_back(const int&) {  // Undefined behavior
    ....
}

示例代码特化了 vector 类的 push_back 函数，其产生的影响是未定义的。



依据

ISO/IEC 14882:2011 17.6.4.2.1(2)-undefined



81. 未经许可，向 posix 命名空间添加声明或定义


示例：

namespace posix {    // Undefined behavior
    ....
}

posix 命名空间是 C++ 的保留命名空间，自定义代码中不应出现名为 posix 的命名空间。



依据

ISO/IEC 14882:2011 17.6.4.2.2(1)-undefined



82. 声明或定义标准库保留名称


示例：

#define override             // Undefined behavior
#define new new(nothrow)     // Undefined behavior
#define string vector<char>  // Undefined behavior


依据

ISO/IEC 14882:2003 17.4.3.1(1)-undefined
ISO/IEC 14882:2011 17.6.4.3(2)-undefined

规则

ID_reservedName
ID_macro_defineReserved



83. 编译器未提供标准头文件，但编译时引入了非标准同名头文件


应选用健全的编译器，并保证编译环境的安全。



依据

ISO/IEC 14882:2003 17.4.3.2(1)-undefined
ISO/IEC 14882:2011 17.6.4.4(1)-undefined



84. 为标准库函数提供不符合要求的参数




依据

ISO/IEC 14882:2003 17.4.3.7(1)-undefined
ISO/IEC 14882:2011 17.6.4.9(1)-undefined



85. 多线程调用标准库函数造成 data race




依据

ISO/IEC 14882:2011 17.6.4.10(1)-undefined



86. 违反标准库函数要求的前置条件，除非标准库函数声明了这种情况会抛出异常


示例：

string s{"abc"};

cout << s[8];       // Undefined behavior
cout << s.at(8);    // Well-defined, throw out_of_range

标准规定 string::at 在参数超出范围时抛出 out_of_range 异常，而 string::operator [] 的参数超出范围会导致未定义的行为。



依据

ISO/IEC 14882:2003 17.4.3.8(1)-undefined
ISO/IEC 14882:2011 17.6.4.11(1)-undefined



87. offsetof 用于非 standard layout 类型，或用于计算静态成员以及成员函数的偏移量


示例：

struct T {
    int* m;

    T();
    virtual ~T();
};

size_t s = offsetof(T, m);  // Undefined behavior


依据

ISO/IEC 14882:2003 18.1(5)-undefined
ISO/IEC 14882:2011 18.2(4)-undefined

规则

ID_deprecatedOffsetof



88. 可变参数列表省略号左侧的形式参数为函数、数组或引用


示例：

void foo(int f(), ...);     // Undefined behavior
void foo(int& n, ...);      // Undefined behavior
void foo(int a[10], ...);   // Undefined behavior


依据

ISO/IEC 14882:2003 18.7(3)-undefined
ISO/IEC 14882:2011 18.10(3)-undefined

规则

ID_forbidVariadicFunction



89. longjmp 跳转使应被执行的析构函数未被执行


示例：

void foo() {
    string obj;
    ....
    longjmp(buf, x);   // Undefined behavior
}

例中局部对象 obj 的析构函数不会被执行，由此引发的问题会导致未定义的行为。



依据

ISO/IEC 14882:2003 18.7(4)-undefined
ISO/IEC 14882:2011 18.10(4)-undefined

规则

ID_forbidLongjmp





快乐编程小能手
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++ -- Undefined behavior
fefe82的专栏
09-24 1157
C++ 未定义行为列表
C++中常见的未定义行为
ghscarecrow的博客
04-04 2078
文章目录前言总结数组越界问题非法多次释放同一块内存空间不恰当使用容器的erase操作其他 前言 在一些程序语言中，在某些情况下存在着一些未定义行为，其中以C和C++最为著名，在C++中，规定某些操作的行为是未定义的。这些未定义行为往往会导致一些程序的错误问题的出现，作为一名合格的程序员，应该极力避免这些未定义行为的出现，让程序的运行结果不会说出现不确定的情况。 总结 在C++中的常见的未定义行为主要有以下几种： 数组越界问题 在C++中，数组越界问题是一个重灾区，也是很多人容易疏忽的点。比如以下的程序 co
c语言中的未定义行为
Mimahoo的博客
04-14 4565
下列 C 代码中，不属于未定义行为的有_A.Int i=0;i=(i++); B.char *p=”hello”;p[1]=’E’; C.char *p=”hello”;char ch=*p++; D.int i=0;printf(“%d%d\n”,i++,i–); E.都是未定义行为 F.都不是未定义行为正确答案: C A，D：表达式的先后顺序，是由编译器决定的，有可能不同 B：常
【我的C/C++语言学习进阶之旅】C++编程常出现错误：Undefined Reference的一些常见情况分析
字节卷动
12-09 2万+
这是导致“Undefined reference”错误的最简单原因。程序员只是忘记了定义对象。考虑以下 C++ 程序。这里我们只是指定了函数的原型，然后在主函数中使用它。# include // 声明函数 int func1();// 调用函数 func1();}编译出错，如下所示：因此，当我们编译这个程序时，会发出“undefined reference to `func1()'”的链接器错误。为了消除这个错误，我们通过提供函数 func1 的定义来更正程序如下。
efs_copy.c:58:6: error: undefined behavior: store to null pointer converted to trap [-Werror,-Wundef
tangxianghha的专栏
08-21 1018
以上错误是在调用高通flash.h时候出现的，一开始以为是static类型的函数无法调用，导致的报错，但是后来验证发现.h中定义的静态函数是可以直接被包含.h文件的.c调用，最后发现传参的结构体有未知参数，删除未知参数，编译通过。 ...
【C++20】编译期检测所有未定义行为undefined behavior和内存泄漏（不借助编译选项以及任何外部工具）
喜欢打篮球的普通人
01-06 877
【C++20】编译期检测所有未定义行为和内存泄漏，不借助任何外部工具。
C程序中的未定义行为（Undefined Behavior）
weixin_42654107的博客
02-12 1838
什么是UB LLVM IR和C语言中都有UB的概念。很多在C语言中看似合理的事都可能导致UB，UB是代码中很多BUG的源泉。 UB在C或类C语言中存在的原因是因为追求极致的性能。类似JAVA之类的语言为了安全和可重现行为的特性，和有意避开了UB，但损失了性能。 在讲解更多的细节之前，先简单讲解一下要实现一个对大部分C程序性能友好的编译器，有哪些关键要素： a) 做好关键算法的实现：寄存器分配、调度等等。 b) 知道大量的小技巧（tricks），比如peephole optimization（将一部
C++对象模型详解
02-20
1.语言中直接支持面向对象...在c++中，通过抽象数据类型（abstractdatatype，ADT），在类中定义数据和函数，来实现数据和函数直接的绑定。概括来说，在C++类中有两种成员数据：static、nonstatic；三种成员函数：stat
详解C++ bitset用法
01-01
C++的 bitset 在 bitset 头文件中，它是一种类似数组的结构，它的每一个元素只能是０或１，每个元素仅用１bit空间。 下面是具体用法 构造函数 bitset常用构造函数有四种，如下 bitset<4> bitset1;　//无参构造，...
详解C++ thread用法总结
08-18
主要介绍了详解C++ thread用法总结，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
C++ Lambda表达式详解
09-15
C++ Lambda表达式详解 C++ Lambda表达式是C++语言的一个重要特性，引入于C++11标准中。它可以作为函数对象使用，可以用来替代一些繁琐的函数声明和定义。Lambda表达式的基本语法结构如下：[capture list] ...
c静态库被c++程序调用时应该注意的问题
csbmary的专栏
05-07 3358
用 gcc 和 ar 编译的c静态库*.a，被c++程序调用，用g++编译。 1.头文件问题：c静态库的头文件一定要被其头文件要被 extern "C" 包围，否则可能出现undefined reference的问题，参考： undefined reference问题总结 http://ticktick.blog.51cto.com/823160/431329
(WWDC) 理解 Undefined Behavior
Ficow Shen
05-22 440
内容概览 什么是 undefined behavior? 编译器 和 undefined behavior 安全性问题 使用工具进行问题检测 Swift 更安全 什么是 undefined behavior? 本国际标准中未作任何规定的行为 —— ISO C++14 Standard 当你的代码语法正确，但是执行的行为不在语言准许的范围...
C++编译时提示类型未定义（undefined）的可能原因
烂笔头
06-29 5307
今天在添加了两个新的cpp和hpp文件后调试，结果编译器一直提示所使用的一个枚举类型未定义，经过仔细确认发现该类型已经正确定义，并且代码文件已经包含到工程中。 后来经过反复确认，再加上网友给的灵感，感觉可能是由于头文件循环引用导致的该枚举类型声明出现了异常！！！经过排查，发现确实如此！！！由于工程比较大，头文件的引用可能也不是很规范，头文件的层层嵌套引用导致出现了A.hpp包含了B.hpp，然后B.hpp又包含了A.hpp，故出现了上述未定义的错误。 因此，当出现莫名其妙的类型未定义错误时，很可能是由于头文
C++中的未定义行为(undefined behavior)
fangyi86的专栏
11-14 6988
<br />之所以想到这个话题，是前段时间一次讨论中提到的new[]一个简单类型的数组，能否用delete而不是delete[]释放的问题。因为明确说了不是类对象，所以这里可以不考虑数组对象析构时的错误，那么这样做可不可以呢？<br />    一种声音是：严格遵守C++标准，保持好习惯；另一种声音：不要生搬经典，要自己实践才知道。<br />    为了弄清这个问题，不得不引入一个词“未定义行为”（undefined behavior）。<br />    In computer science, und
C++编译提示“undefined reference to...”
热门推荐
rong_bao_bao的博客
11-17 3万+
编写的一个简单C++时钟Clock类，放入了头文件中，主函数在调用头文件进行编译时出现上述错误，具体代码如下： clock.h: #include &lt;iostream&gt; using namespace std; class Clock { private: int h,m,s; public: Clock(); ~...
undefined reference问题总结
Listening_music的专栏
04-17 1万+
<br />最近在Linux下编程发现一个诡异的现象，就是在链接一个静态库的时候总是报错，类似下面这样的错误： (.text+0x13): undefined reference to `func' <br />    关于undefined reference这样的问题，网上也有很多的说法，在此，我以详细地示例给出其中的各种原因说明以及解决方法，然后再给出我所遇到的与大家均不同的问题。<br />1.  链接时缺失了相关目标文件（.o）<br />    测试代码如下：<br />  <br />  
C++程序中出现undefined reference to ......
好习惯成就伟大
11-27 1万+
在C++代码中调用C的库文件，需加上extern "C"，用来告知编译器：这是一个用C写成的库文件，请用C的方式连接他们。 Undefined reference to 错误:这类错误是在连接过程中出现的，可能有两种原因∶ 一是使用者自己定义的函数或者全局变量所在源代码文件，没有被编译、连接，或者干脆还没有定义，这 需要使用者根据实际情况修改源程序，给出全局变量或者函数的定义体； 1) 可以...
C++ 多态
最新发布
wxk2227814847的博客
07-10 501
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
c++递推算法详解ppt课件.ppt
11-13
"C++递推算法的详细讲解和实例解析" C++递推算法是一种用于解决数学和计算机科学问题的有效工具，它通过定义一个或多个递推关系来解决问题。递推算法通常涉及到从一个或几个初始值（边界条件）出发，通过一系列规则...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值