“静态常量”与“#define”相比与“枚举”

Question

下面的 C 语言语句中，哪一个更好用？

static const int var = 5;

或

#define var 5

或

enum { var = 5 };

Answer 1

这取决于您需要什么价值。您（以及到目前为止的其他人）省略了第三种选择：

1. static const int var = 5;
2. #define var 5
3. enum { var = 5 }; code>

忽略有关名称选择的问题，那么：

• 如果需要传递指针，则必须使用 (1)。
• 由于 (2) 显然是一个选项，因此您不需要传递指针。
• (1) 和 (3) 在调试器的符号表中都有一个符号 - 这使得调试更容易。 (2) 更有可能没有符号，让您想知道它是什么。
• (1) 不能用作全局范围内数组的维度； (2)和(3)都可以。
• (1) 不能在函数作用域内用作静态数组的维度； (2)和(3)都可以。
• 在C99下，所有这些都可以用于本地数组。从技术上讲，使用 (1) 意味着使用 VLA（可变长度数组），尽管“var”引用的维度当然会固定为 5。
• (1) 不能用在 switch 语句等地方； (2)和(3)都可以。
• (1)不能用来初始化静态变量； (2)和(3)都可以。
• (2) 可以更改您不想更改的代码，因为它由预处理器使用； (1)和(3)都不会产生这样意想不到的副作用。
• 可以检测预处理器中是否设置了(2)； (1) 和 (3) 都不允许这样做。

因此，在大多数情况下，更喜欢“枚举”而不是其他选择。否则，第一个和最后一个要点很可能是控制因素——如果你需要同时满足这两个要点，你就必须更加努力地思考。

如果您询问有关 C++ 的问题，那么您每次都会使用选项 (1) - static const。

Answer 2

一般来说：

static const

因为它尊重范围并且是类型安全的。

我能看到的唯一警告：如果您希望变量可能在命令行上定义。还有一个替代方案：

#ifdef VAR // Very bad name, not long enough, too general, etc..
  static int const var = VAR;
#else
  static int const var = 5; // default value
#endif

只要有可能，就使用类型安全的替代方案来代替宏/省略号。

如果您确实需要使用宏（例如，您想要 __FILE__ 或 __LINE__），那么您最好非常仔细地命名您的宏：在其 命名约定 Boost 建议全部大写，以项目名称开头（此处为 BOOST_），在仔细阅读库时，您会注意到（通常）后面跟着特定的名称区域（图书馆），然后用一个有意义的名称。

它通常会导致名字很长:)

Answer 3

具体来说，在C语言中？在 C 中，正确的答案是：使用 #define （或者，如果合适，使用 enum）。

虽然拥有 const< 的作用域和类型属性是有益的/code> 对象，实际上 C（与 C++ 相对）中的 const 对象不是真正的常量，因此在大多数实际情况下通常是无用的。

因此，在 C 中，选择应该取决于您计划如何使用常量。例如，您不能使用 const int 对象作为 case 标签（但宏可以使用）。您不能使用 const int 对象作为位字段宽度（尽管宏可以工作）。在 C89/90 中，您不能使用 const 对象来指定数组大小（而宏可以工作）。即使在 C99 中，当您需要非 const 对象来指定数组大小rel="noreferrer">VLA 数组。

如果这对您很重要，那么它将决定您的选择。大多数时候，您别无选择，只能在 C 中使用#define。并且不要忘记另一种选择，它可以在 C 中生成真正的常量 - enum。

在 C++ 中，const 对象是真正的常量，因此在 C++ 中，最好选择 const 变体（在 C++ 中不需要显式的 static）尽管）。

Answer 4

static const和#define的区别在于前者使用内存，后者不使用内存进行存储。其次，您不能传递#define 的地址，而可以传递static const 的地址。其实这取决于我们在什么情况下，我们需要在这两者中选择其一。两人在不同的情况下都处于最佳状态。请不要假设一个比另一个更好... :-)

如果情况确实如此，丹尼斯·里奇会保留最好的一个...哈哈哈...:-)

Answer 5

在 C 中，#define 更为流行。您可以使用这些值来声明数组大小，例如：

#define MAXLEN 5

void foo(void) {
   int bar[MAXLEN];
}

据我所知，ANSI C 不允许您在此上下文中使用static const。在 C++ 中，在这些情况下您应该避免使用宏。您可以编写

const int maxlen = 5;

void foo() {
   int bar[maxlen];
}

甚至省略 static，因为内部链接已由 const 隐含[仅在 C++ 中]。

Answer 6

C 中 const 的另一个缺点是您无法在初始化另一个 const 时使用该值。

static int const NUMBER_OF_FINGERS_PER_HAND = 5;
static int const NUMBER_OF_HANDS = 2;

// initializer element is not constant, this does not work.
static int const NUMBER_OF_FINGERS = NUMBER_OF_FINGERS_PER_HAND 
                                     * NUMBER_OF_HANDS;

即使这也不适用于 const，因为编译器不会将其视为常量：

static uint8_t const ARRAY_SIZE = 16;
static int8_t const lookup_table[ARRAY_SIZE] = {
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}; // ARRAY_SIZE not a constant!

在这些情况下我很乐意使用类型化 const，否则......

Answer 7

如果你能摆脱它，static const 有很多优点。它遵循正常的作用域原则，在调试器中可见，并且通常遵循变量所遵循的规则。

然而，至少在最初的 C 标准中，它实际上并不是一个常量。如果您使用#define var 5，则可以编写 int foo[var]; 作为声明，但您不能这样做（除非作为编译器扩展） static const int var = 5; 在 C++ 中情况并非如此，其中 static const 版本可以在 #define 版本的任何地方使用。可以，而且我相信 C99 也是如此。

但是，永远不要使用小写名称命名 #define 常量，它会覆盖该名称的任何可能使用，直到翻译单元结束。宏常量实际上应该位于它们自己的命名空间中，传统上全是大写字母，也许带有前缀。

Answer 8

最好使用 const，而不是 #define。这是因为 const 由编译器处理，#define 由预处理器处理。就像 #define 本身不是代码的一部分（粗略地说）。

示例：

#define PI 3.1416

符号名 PI 可能永远不会被编译器看到；在源代码到达编译器之前，它可能会被预处理器删除。因此，名称 PI 可能不会输入到符号表中。如果您在编译期间遇到涉及常量使用的错误，这可能会令人困惑，因为错误消息可能引用 3.1416，而不是 PI。如果 PI 是在您没有编写的头文件中定义的，那么您将不知道 3.1416 来自哪里。

这个问题也可能出现在符号调试器中，因为您正在编程的名称可能不在符号表中。

解决方案：

const double PI = 3.1416; //or static const...

Answer 9

如果你有像 mystruct.var 这样的东西，#define var 5 会给你带来麻烦。

例如，

struct mystruct {
    int var;
};

#define var 5

int main() {
    struct mystruct foo;
    foo.var = 1;
    return 0;
}

预处理器将替换它，并且代码将无法编译。因此，传统的编码风格建议所有常量#define都使用大写字母以避免冲突。

Answer 10

我编写了快速测试程序来演示一个差异：

#include <stdio.h>

enum {ENUM_DEFINED=16};
enum {ENUM_DEFINED=32};

#define DEFINED_DEFINED 16
#define DEFINED_DEFINED 32

int main(int argc, char *argv[]) {

   printf("%d, %d\n", DEFINED_DEFINED, ENUM_DEFINED);

   return(0);
}

编译时会出现以下错误和警告：

main.c:6:7: error: redefinition of enumerator 'ENUM_DEFINED'
enum {ENUM_DEFINED=32};
      ^
main.c:5:7: note: previous definition is here
enum {ENUM_DEFINED=16};
      ^
main.c:9:9: warning: 'DEFINED_DEFINED' macro redefined [-Wmacro-redefined]
#define DEFINED_DEFINED 32
        ^
main.c:8:9: note: previous definition is here
#define DEFINED_DEFINED 16
        ^

请注意，当定义给出警告时，枚举会给出错误。

Answer 11

尽管问题是关于整数，但值得注意的是，如果您需要常量结构或字符串，#define 和枚举是无用的。它们通常都作为指针传递给函数。 （对于字符串，这是必需的；对于结构，它的效率要高得多。）

至于整数，如果您处于内存非常有限的嵌入式环境中，您可能需要担心常量的存储位置以及如何编译对它的访问。编译器可能在运行时添加两个 const，但在编译时添加两个 #define。 #define 常量可以转换为一条或多条 MOV [立即] 指令，这意味着该常量有效地存储在程序存储器中。 const 常量通常存储在数据存储器中的单独部分中，例如 .const 或 .rodata。在具有哈佛架构的系统中，性能和内存使用可能存在差异，尽管差异可能很小。它们可能对于内部循环的核心优化很重要。

Answer 12

该定义

const int const_value = 5;

并不总是定义一个常量值。某些编译器（例如 tcc 0.9.26）仅分配名称为“const_value”的内存。使用标识符“const_value”您不能修改该内存。但是您仍然可以使用另一个标识符修改内存：

const int const_value = 5;
int *mutable_value = (int*) &const_value;
*mutable_value = 3;
printf("%i", const_value); // The output may be 5 or 3, depending on the compiler.

这意味着定义是定义

#define CONST_VALUE 5

不能以任何方式修改的常量值的唯一方法。

Answer 13

不要认为“哪个总是最好的”有答案，但是，正如 Matthieu 所说，

static const

是类型安全的。不过，我对 #define 最大的不满是在 Visual Studio< 中进行调试时/a> 您无法观察该变量。它给出了找不到符号的错误。

Answer 14

顺便说一句，#define 的替代方案是“enum”，它提供了适当的范围，但表现得像“真正的”常量。例如：

enum {number_ten = 10};

在许多情况下，定义枚举类型并创建这些类型的变量很有用；如果这样做了，调试器也许能够根据变量的枚举名称来显示变量。

然而，这样做的一个重要警告是：在 C++ 中，枚举类型与整数的兼容性有限。例如，默认情况下，无法对它们执行算术运算。我发现这是枚举的一个奇怪的默认行为；虽然拥有“严格枚举”类型会很好，但考虑到 C++ 与 C 普遍兼容的愿望，我认为“枚举”类型的默认行为应该与整数互换。

Answer 15

一个简单的区别：

在预处理时，常量被替换为它的值。
因此，您无法将取消引用运算符应用于定义，但可以将取消引用运算符应用于变量。

正如您所想，define 比 static const 更快。

例如，

#define mymax 100

您不能执行 printf("address ofconstant is %p",&mymax);。

但是

const int mymax_var=100

你可以这样做 printf("address ofconstant is %p",&mymax_var);。

更清楚地说，定义在预处理阶段被它的值替换，因此我们没有在程序中存储任何变量。我们只有使用定义的程序文本段中的代码。

然而，对于 static const，我们有一个分配在某处的变量。对于gcc来说，static const分配在程序的文本段中。

上面，我想讲述引用运算符，因此将取消引用替换为引用。

Answer 16

我们查看了 MBF16X 上生成的汇编代码...两种变体都会产生相同的算术运算代码（例如 ADD Immediate）。

因此，const int 是类型检查的首选，而 #define 是旧式。也许它是特定于编译器的。因此，请检查您生成的汇编代码。

Answer 17

我不确定我是否正确，但在我看来，调用 #defined value 比调用任何其他正常声明的变量（或 const 值）要快得多。

这是因为当程序运行时，它需要使用一些正常声明的变量，它需要跳转到内存中的确切位置来获取该变量。

相反，当使用#defined值时，程序不需要跳转到任何分配的内存；它只需要值。如果#define myValue 7 且程序调用myValue，则其行为与仅调用7 时的行为完全相同。