Question

我当前的代码使用一些#define来将所有常量放在一个.h文件中。

程序规范的一个新修改就是这样，这将需要一些常量依赖于大小写，即变量将设置大小写（可能是3个），并根据它必须使用适当的值对于其中一些常数，例如：

#define CONSTANT1 1.0F
#define CONSTANT2 2.0F

float foo(float var)
{
    return (CONSTANT1 + CONSTANT2*var);
}

我现在可以想到以两种方式解决这个问题：

Way1-每个可能值都有#define，实现switch-case代码的3个副本，并在每个代码中使用相应的常量

#define CONSTANT1_a 1.0F
#define CONSTANT2_a 2.0F

#define CONSTANT1_b 2.0F
#define CONSTANT2_b 3.0F

#define CONSTANT1_c 3.0F
#define CONSTANT2_c 4.0F

switch(var_case)
{
case 0:
     float foo(float var)
     {
         return (CONSTANT1_a + CONSTANT2_a*var);
     }
case 1:
     float foo(float var)
     {
         return (CONSTANT1_b + CONSTANT2_b*var);
     }
case 2:
     float foo(float var)
     {
         return (CONSTANT1_c + CONSTANT2_c*var);
     }
}

Way2-常量不再是#define s，而是作为全局数组定义在相应文件的顶部，并且具有单个实现的代码，其中“case”选择数组中的位置

float CONSTANT1 [] = {1.0F,2.0F,3.0F};
float CONSTANT2 [] = {2.0F,3.0F,4.0F};

float foo(float var)
{
    return (CONSTANT1[var_case] + CONSTANT2[var_case]*var);
}

我倾向于第二种解决方案，因为它似乎更加可维护和清洁，但使用全局数组听起来并不是很好。还有其他选择吗？有没有办法让#define包含一个数组？（或等同的东西）

修改对于之前没有提及，我表示歉意。代码必须是C89（ANSI C）。

Answer 1

使用全局数组作为常量很好。您的预处理器常量首先是全局的。只需添加const即可。

<强> constants.c

const float CONSTANT1 [] = {1.0F,2.0F,3.0F};
const float CONSTANT2 [] = {2.0F,3.0F,4.0F};

<强> constants.h

extern const float CONSTANT1 [];
extern const float CONSTANT2 [];

或者，如果要将数组专用于当前编译单元，请添加static。

static const float CONSTANT1 [] = {1.0F,2.0F,3.0F};

Answer 2

我现在无法验证这一点，但这可能有用：#define宏可以是一个数组，或几乎任何东西。这样做：

#define CONSTANTS int temp[]={1,2,3,4};
//.. Later..
int x = (CONSTANTS)[2];

所有#define都会对编译器说：在编译之前，将所定义的常量（在本例中为CONSTANTS）的代码中的每个实例替换为后来的任何实例（在本例中为＆＃34; temp [] = {1,2,3,4}＆＃34）。所以上面的代码将被编译为

int x = (temp[]={1,2,3,4})[2];

但这变得不可靠，因为temp必须是该范围内的保留变量名。我建议使用开关或替换变量加上几个三元条件作为单线程。

全局数组或'#define'的“数组”的替代品？

2 个答案: