C 中的类型安全

Question

有没有办法让 C 更加了解类型并确保类型安全？
考虑一下：

typedef unsigned cent_t;
typedef unsigned dollar_t;

#define DOLLAR_2_CENT(dollar)       ((cent_t)(100*(dollar)))

void calc(cent_t amount) {
    // expecting 'amount' to semantically represents cents...
}

int main(int argc, char* argv[]) {
    dollar_t amount = 50;
    calc(DOLLAR_2_CENT(amount));  // ok
    calc(amount);                 // raise warning
    return 0;
}

有没有办法让上面的代码至少引起 gcc 的警告？
我知道我可以使用 C-structs 来包装 unsigneds 并达到预期的结果，我只是想知道是否有更优雅的方法来做到这一点。
还能再多一点吗？

Answer 1

问题在于 C 不会将您的两个 typedef 视为独特的类型，因为它们都是类型 unsigned。

有各种技巧可以避免这种情况。一件事是将您的类型更改为枚举。好的编译器会对从某个枚举类型到任何其他类型的隐式转换强制执行更强的类型警告。

即使你没有一个好的编译器，使用枚举你也可以这样做：

typedef enum { FOO_CENT  } cent_t;
typedef enum { FOO_DOLLAR} dollar_t;

#define DOLLAR_2_CENT(dollar)       ((cent_t)(100*(dollar)))

void calc(cent_t amount) {
    // expecting 'amount' to semantically represents cents...
}

#define type_safe_calc(amount) _Generic(amount, cent_t: calc(amount))

int main(int argc, char* argv[]) {
    dollar_t amount = 50;
    type_safe_calc(DOLLAR_2_CENT(amount));  // ok
    type_safe_calc(amount);         // raise warning

    return 0;
}

---

更传统/传统的技巧是使用通用结构包装器，在其中使用“票证”枚举来标记类型。示例：

typedef struct
{
  type_t type;
  void*  data;
} wrapper_t;

...

cent_t my_2_cents;
wrapper_t wrapper = {CENT_T, &my_2_cents};

...

switch(wrapper.type)
{
  case CENT_T: calc(wrapper.data)
  ...
}

优点是它适用于任何 C 版本。缺点是代码和内存开销，并且只允许运行时检查。

Answer 2

别名在 C 中具有非常具体的狭义含义，这不是您的想法。您可能想说“typedefing”。

答案是否定的，你不能。无论如何都不是优雅的方式。您可以为每种数字类型使用一个结构，并使用一组单独的函数对每个数字类型进行算术运算。除非涉及到乘法，否则你就不走运了。为了将英尺乘以磅，您需要第三种类型。您还需要平方英尺、立方英尺、秒的负二次方以及无数其他类型的类型。

如果这是你所追求的，那么 C 不是正确的语言。

Answer 3

您需要在构建过程中使用静态分析工具来实现这一点。

例如，如果您在代码上运行 PCLint，它会给出以下输出：

  [Warning 632] Assignment to strong type 'cent_t' in context: arg. no. 1
  [Warning 633] Assignment from a strong type 'dollar_t' in context: arg. no. 1

http://www.gimpel.com/html/strong.htm

Answer 4

编辑：这里有一个替代方案，即使在 C89 中也可以使用，以防你的编译器不支持 _Generic 选择器（很多编译器不支持，而且你经常被机器上安装的东西所困扰）。

您可以使用宏来简化struct 包装器的使用。

#define NEWTYPE(nty,oty) typedef struct { oty v; } nty
#define FROM_NT(ntv)       ((ntv).v)
#define TO_NT(nty,val)     ((nty){(val)})  /* or better ((nty){ .v=(val)}) if C99 */


NEWTYPE(cent_t, unsigned);
NEWTYPE(dollar_t, unsigned);

#define DOLLAR_2_CENT(dollar)       (TO_NT(cent_t, 100*FROM_NT(dollar)))

void calc(cent_t amount) {
     // expecting 'amount' to semantically represents cents...
}  

int main(int argc, char* argv[]) {
    dollar_t amount = TO_NT(dollar_t, 50);  // or alternatively {50};
    calc(DOLLAR_2_CENT(amount));  // ok
    calc(amount);                 // raise warning
    return 0;
}

你比警告更强大。这是 gcc 5.1 的编译结果

$ gcc -O3 -Wall Edit1.c Edit1.c：在函数“main”中： Edit1.c:17:10: error: 'calc' 的参数 1 的类型不兼容 计算（金额）； // 发出警告 ^ Edit1.c:10:6: note: 预期为“cent_t {aka struct }”，但参数类型为“dollar_t {aka struct }” void calc(cent_t amount);// {

这里是 gcc 3.4 的结果

$ gcc -O3 -Wall Edit1.c Edit1.c：在函数'main'中： Edit1.c:17：错误：'calc' 的参数 1 的类型不兼容