C++ Switch 不会使用外部定义的变量作为 case 进行编译

Question

我正在使用 MinGW GNU 编译器编写 C++，当我尝试使用外部定义的整数变量作为 switch 语句中的 case 时，就会出现问题。我收到以下编译器错误：“case 标签不会简化为整数常量”。

因为我已将整数变量定义为 extern 我相信它应该编译，有谁知道问题可能是什么？

下面是一个示例：

test.cpp

#include <iostream>
#include "x_def.h"

int main()
{
   std::cout << "Main Entered" << std::endl;


   switch(0)
   {
      case test_int:
         std::cout << "Case X" << std::endl;
         break;
      default:
         std::cout << "Case Default" << std::endl;
         break;
   }

   return 0;
}

x_def.h

extern const int test_int;

x_def.cpp

const int test_int = 0;

该代码将在 Visual C++ 2008 上正确编译。此外，我的一位蒙大拿朋友检查了 ISO C++ 标准，发现任何常量整数表达式都应该有效。这可能是编译器错误还是我错过了一些明显的东西？

这是我的编译器版本信息：

从 C:/MinGW/bin/../lib/gcc/mingw32/3.4.5/specs 读取规范
配置为：../gcc-3.4.5-20060117-3/configure --with-gcc --with-gnu-ld --with-gnu-as --host=mingw32 --target=mingw32 --prefix= /mingw --enable-threads --disable-nls --enable-languages=c,c++,f77,ada,objc,java --disable-win32-registry --disable-shared --enable-sjlj-exceptions --启用-libgcj --disable-java-awt --without-x --enable-java-gc=boehm --disable-libgcj-debug --enable-interpreter --enable-hash-synchronization --enable-libstdcxx-debug
线程模型：win32
gcc版本3.4.5（mingw-vista专用r3）

Answer 1

case 标签需要一个积分常量表达式，它具有严格的要求，使其值能够在编译时和使用时确定。

从 5.19 [expr.const] 开始，“整型常量表达式只能涉及文字 (2.13)、枚举器、const 变量或整型或枚举类型的静态数据成员用常量表达式初始化（8.5），...”。

当您在需要常量表达式的地方使用 test_int 时，它是一个声明为 extern 的 const 变量，并且没有任何初始值设定项，并且不会满足常量表达式的要求，尽管事实上您确实使用另一个翻译单元中的整型常量表达式来初始化它。 （*从标准的措辞来看，这并不完全清楚，但这是我目前对它的解释。）

标准中的限制不允许使用，例如：

void f(int a, int b)
{
    const int c = b;

    switch (a)
    {
    case c:
        //...
    }
}

在您的示例中，当编译器编译 test.cpp，它无法确定 x_def.cpp 中的初始化程序可能是什么。您可能已经这样做了：

const int test_int = (int)time();

显然，在这两个示例中，const int 的值都无法在编译时确定，而这正是整型常量表达式的目的。

Answer 2

大小写标签必须是编译时常量。这意味着编译器必须能够在编译时替换该值。尽管您的值是常量，但编译器至少要到链接时才能知道它们的值。

Answer 3

VC++是对的，g++是错的。 case 标签必须是整型常量表达式（第 6.4.2/2 节），并且用常量表达式初始化的整数类型 const 变量是常量表达式（第 5.19/1 节）。

编辑：主要是针对帕维尔，以及他对可能的博士的建议。 §5.19/2 已被完全重写。 C++0x 添加了一个全新的 constexpr 概念，它大大扩展了常量表达式的内容。例如，在当前标准下，类似：

int x() { return 10; }
const int y = x();

y 不是常量表达式。我们都可以很容易地看到它是用文字10（间接）初始化的，但是编译器仍然不允许它作为常量表达式。在新标准下，可以将 x() 指定为 constexpr，而 y 将指定为常量表达式。

正如 N2960 中的表述，§5.19/2 表示表达式是常量表达式，除非它使用以下列表中的内容。然后它给出了一个长达一页的列表，但使用未在当前编译单元中初始化的 const 变量似乎不是其中之一。 [编辑：见下文——阅读 CWG 第 721 期，我改变了主意。]

至于 VC++ 是正确的而 g++ 是错误的，我的意思只是在这个非常具体的方面。如果您谈论的是使标准的每个部分都正确，那么毫无疑问两者都是“错误的”。我怀疑是否有人正在致力于为其中任何一个实现export。

然而，export 确实指出了 C++ 似乎愿意将决策推迟到链接时间的程度。两阶段名称查找意味着当编译导出的模板时，除了常量表达式之外还有很多东西是不确定的。它甚至可能不知道特定的名称是指函数还是对象——但毫无疑问，标准确实确实需要这一点。在我看来，当前的问题是一个更容易处理的问题。

编辑：我做了一些搜索，发现了核心工作组问题 721。Jame 的问题与手头的问题非常接近（“但是，这并不要求，因为它大概应该如此，初始化发生在同一个翻译单元中，并且在常量表达式之前...”）。拟议的决议添加了这样一句话：“……在前面进行初始化……”。至少在我读到的时候，这意味着委员会同意在当前标准下，该代码必须被接受，但在新标准下，这是不允许的。

该措辞已于今年 7 月达成一致，但（还没有？）出现在 N2960 中，我认为 N2960 是 C++0x 的最新草案。

Answer 4

我无法使用 VC++2008 在一个简单的示例中重现此内容：

test.cpp:

extern const int n;
int main() {
    switch (0) {
    case n: break;
    }
}

test2.cpp:

extern const int n = 123;

编译为：

cl.exe test.cpp test2.cpp

输出：

test.cpp(4) : 错误 C2051: case 表达式不是常量

Answer 5

MS 编译器在这里有点顽皮。当您在同一编译单元中编译常量初始化和使用常量的 case 语句时，它会在编译时计算出常量值。

一旦您尝试使用初始化的编译单元（即包含初始化的 cpp 文件或其包含的任何文件）的 extern const outside ，编译器将抛出几乎相同的错误。 Fred Larson 是正确的，编译器不应该知道链接时间之前的常量值，因此它不能被接受作为开关常量，这只是 MS 编译器的一点作弊。

解决您的问题的方法是使用宏，您有什么理由不想#define常量吗？

Answer 6

这是一个更简单的测试：

test_int.cpp:

const int test_int = 10;

ma​​in.cpp:

#include <iostream>
using std::cout;
using std::endl;

extern const int test_int;

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

在 G++ 中，我得到一个未定义的引用。然而，在 C 中做同样的事情是可行的。根据 http://gcc.gnu.org/ml/gcc/ 2005-06/msg00325.html ，const 变量在 C++ 中隐式具有内部链接。在 C 中似乎并非如此。

Answer 7

我正在使用“gcc (SUSE Linux) 4.3.2”并具有类似的效果，但仍然有点奇怪。

我的定义是：

namespace operations{
   const cOpDummy OpDummy();
   const cInitOperator InitOperator();
};

const unsigned long ulNumberOfOperations = 2;

const cOperation * arrayOperations[] = {
   & (operations::OpDummy),
   & (operations::InitOperator)
};

另一个文件中的 extern 声明是：

extern const unsigned long ulNumberOfOperations;
extern const cOperation * arrayOperations[];

有趣的是：编译器只为“ulNumberOfOperations”提供“对 ulNumberOfOperations 的未定义引用”，但对“arrayOperations[]”则可以。
我的解决方法是声明“ulNumberOfOperations”不是常量。

Answer 8

从 c++11 开始，您可以构建一个小模板框架来为您提供如下语法：

void test(int a, int x, int y, int z)
{
    std::cout << "given " << a << ", choosing ";
    given(a)
        .when(x, [] { std::cout << "x\n"; })
        .when(y, [] { std::cout << "y\n"; })
        .when(z, [] { std::cout << "z\n"; })
        .when(any_other, [] { std::cout << "none of the above\n"; });
}

完整演示：

#include <iostream>


struct any_object {};
constexpr auto any_other = any_object {};

template<class Expr>
struct when_object
{

    template<class T, class F>
    constexpr when_object& when(T const& value, F&& f)
    {
        if (not executed and expr == value) {
            executed = true;
            f();
        }
        return *this;
    }

    template<class F>
    constexpr void when(any_object, F&& f)
    {
        if (not executed) {
            executed = true;
            f();
        }
    }

    Expr const& expr;
    bool executed = false;
};

template<class Expr>
constexpr auto given(Expr const& expr)
{
    return when_object<Expr> {expr};
}

void test(int a, int x, int y, int z)
{
    std::cout << "given " << a << ", choosing ";
    given(a)
        .when(x, [] { std::cout << "x\n"; })
        .when(y, [] { std::cout << "y\n"; })
        .when(z, [] { std::cout << "z\n"; })
        .when(any_other, [] { std::cout << "none of the above\n"; });
}


int main()
{
    test(4, 4, 5, 6);
    test(4, 3, 4, 5);
    test(4, 2, 3, 4);
    test(1, 2, 3, 4);
}

预期结果：

given 4, choosing x
given 4, choosing y
given 4, choosing z
given 1, choosing none of the above