C 问题：off_t（和其他有符号整数类型）最小值和最大值

Question

我偶尔会遇到一种整数类型（例如 POSIX 有符号整数类型 off_t），如果有一个用于其最小值和最大值的宏会很有帮助，但我不知道如何制作一个是真正的便携式。

对于无符号整数类型，我一直认为这很简单。 0 为最小值，~0 为最大值。此后我读到了几个不同的 SO 线程，它们建议使用 -1 而不是 ~0 以实现可移植性。这里有一个有趣的话题，有一些争议：
c++ - 使用安全吗 - 1 将所有位设置为真？ - Stack Overflow

然而，即使在阅读了这个问题之后，我仍然感到困惑。另外，我正在寻找同时兼容 C89 和 C99 的东西，所以我不知道相同的方法是否适用。假设我有一个 uint_whatever_t 类型。我不能先转换为 0，然后按位求补吗？这样可以吗？：

#define UINT_WHATEVER_T_MAX ( ~ (uint_whatever_t) 0 )

有符号整数类型看起来是一个更难破解的难题。我已经看到了几种不同的可能解决方案，但只有 一个 似乎是可移植的。要么是这样，要么是不正确的。我在谷歌搜索 OFF_T_MAX 和 OFF_T_MIN 时发现了它。感谢克里斯蒂安·比埃尔：

#define MAX_INT_VAL_STEP(t) \
    ((t) 1 << (CHAR_BIT * sizeof(t) - 1 - ((t) -1 < 1))) 

#define MAX_INT_VAL(t) \
    ((MAX_INT_VAL_STEP(t) - 1) + MAX_INT_VAL_STEP(t))

#define MIN_INT_VAL(t) \
    ((t) -MAX_INT_VAL(t) - 1)

[...]
#define OFF_T_MAX MAX_INT_VAL(off_t) 

我在 C89 中找不到有关不同允许类型的有符号整数表示的任何内容，但 C99 在 §J.3.5 中有关于整数可移植性问题的注释：

有符号整数类型是否使用符号和大小、二进制表示 补语，还是一个人的补语，以及非凡的价值是否是一个陷阱 表示或普通值（6.2.6.2）。

这似乎意味着只能使用列出的三个有符号数字表示形式。含义是否正确，上面的宏是否与所有三种表示形式兼容？

---

Other thoughts:
It seems that the function-like macro MAX_INT_VAL_STEP() would give an incorrect result if there were padding bits. I wonder if there is any way around this.

通读 维基百科上的有符号数字表示，我发现对于所有三个有符号整数表示，任何有符号整数类型的 MAX 为：
符号位关闭，所有值位打开（全部三个）
它的 MIN 可以是：
符号位打开，所有值位打开（符号和幅度）
符号位打开，所有值位关闭（一个/两个补码）

我想我可以通过这样做来测试符号和幅度：

#define OFF_T_MIN ( ( ( (off_t)1 | ( ~ (off_t) -1 ) ) != (off_t)1 ) ? /* sign and magnitude minimum value here */ : /* ones and twos complement minimum value here */ )

然后，由于符号和幅度是符号位打开，并且所有值位打开不会是 off_t 的最小值情况是 ~ (off_t) 0 ？对于一/二补码最小值，我需要某种方法来关闭所有值位，但保留符号位。在不知道值位数的情况下不知道如何做到这一点。另外，符号位是否保证始终比最高有效值位高一位？

谢谢，如果这篇文章太长，请告诉我

---

编辑于 2010 年 12 月 29 日下午 5 点（美国东部时间）：
正如下面 ephemient 回答的那样，为了获取无符号类型最大值，(unsigned type)-1 比 ~0 甚至 ~(unsigned type)0 更正确。据我所知，当您使用 -1 时，它与 0-1 相同，这总是会导致无符号类型中的最大值。

此外，因为可以确定无符号类型的最大值，所以可以确定无符号类型中有多少个值位。感谢 Hallvard B. Furuseth 在回复 关于 comp.lang.c 的问题

/* Number of bits in inttype_MAX, or in any (1<<b)-1 where 0 <= b < 3E+10 */
#define IMAX_BITS(m) ((m) /((m)%0x3fffffffL+1) /0x3fffffffL %0x3fffffffL *30 \
                  + (m)%0x3fffffffL /((m)%31+1)/31%31*5 + 4-12/((m)%31+3))

IMAX_BITS(INT_MAX) 计算 int 中的位数，IMAX_BITS((unsigned_type)-1) 计算 unsigned_type 中的位数。无论如何，直到有人实现 4 GB 整数:-)

然而，我的问题的核心仍然没有得到解答：如何通过宏确定有符号类型的最小值和最大值。我还在研究这个。也许答案是没有答案。

如果您没有在 StackOverflow 上查看此问题，则在大多数情况下您无法看到建议的答案，直到它们被接受为止。建议在 StackOverflow 上查看此问题。

Answer 1

我相信我终于解决了这个问题，但该解决方案仅在配置时可用，而不是在编译时或运行时可用，所以它仍然不知道。如下：

HEADERS="#include <sys/types.h>"
TYPE="off_t"
i=8
while : ; do
printf "%s\nstruct { %s x : %d; };\n" "$HEADERS" "$TYPE" $i > test.c
$CC $CFLAGS -o /dev/null -c test.c || break
i=$(($i+1))
done
rm test.c
echo $(($i-1))

这个想法来自 6.7.2.1 第 3 段：

指定位域宽度的表达式应为整数常量
具有不超过对象宽度的非负值的表达式
省略冒号和表达式时将指定的类型。如果该值为零，
声明不应有声明符。

如果这能带来任何在编译时解决问题的想法，我将非常高兴。

Answer 2

令人惊讶的是，C 在算术运算之前将类型提升到 int，结果至少为 int 大小。 （类似的奇怪之处包括 'a' 字符文字的类型为 int，而不是 char。）

int a = (uint8_t)1 + (uint8_t)-1;
   /* = (uint8_t)1 + (uint8_t)255 = (int)256 */
int b = (uint8_t)1 + ~(uint8_t)0;
   /* = (uint8_t)1 + (int)-1 = (int)0 */

因此 #define UINT_WHATEVER_T_MAX ( ~ (uint_whatever_t) 0 ) 不一定没问题。

Answer 3

有符号最大值：

#define GENERIC_S_MAX(stype) ((stype) ((1ULL << ((sizeof(stype) * 8) - 1)) - 1ULL))

假设您的系统使用二进制补码，有符号最小值应该是：

#define GENERIC_S_MIN(stype) ((stype) -1 - GENERIC_S_MAX(stype))

这些应该是完全可移植的，除了 long long 在技术上是 C89 中的编译器扩展。这也避免了有符号整数上溢/下溢的未定义行为。

Answer 4

对于符号数值表示，这相当简单（无论如何，对于至少与 int 一样宽的类型）：

#define SM_TYPE_MAX(type) (~(type)-1 + 1)
#define SM_TYPE_MIN(type) (-TYPE_MAX(type))

不幸的是，符号数值表示在地面上相当薄弱；）

Answer 5

仅快速回答：

#define UINT_WHATEVER_T_MAX ( ~ (uint_whatever_t) 0 ) 对我来说看起来不错，-1 的偏好是 uint_whatever_t = -1; 比 更简洁code>uint_whatever_t = ~(uint_whatever_t)0;

(CHAR_BIT * sizeof(t)) 看起来并不严格符合我的要求。您对填充位的看法是正确的，因此该值可能比类型的宽度大得多，除非 Posix 关于 off_t 另有说明。

相比之下，C99 中的固定宽度整数类型不得具有填充位，因此对于intN_t，您可以使用大小来推断宽度。它们也保证是补码。

这似乎意味着只有
这三个列出的签名号码
可以使用表示法。是
暗示正确

是的。 6.2.6.2/2 列出了符号位的三种允许的含义，以及三种允许的带符号数字表示形式。

是符号位，保证始终
比最重要的人更重要
有效值位

它间接要求比值位更重要，事实上（再次参见 6.2.6.2/2）“作为值位的每个位应具有与
相应无符号类型的对象表示中的相同位”。因此值位必须是从最低有效位开始的连续范围。

但是，您不能仅可移植地设置符号位。请阅读 6.2.6.2/3 和 / 4，关于负零，请注意，即使实现原则上使用具有它们的表示，它也不必支持它们，并且在符号+幅度实现上没有保证生成负零的方法。 。

[编辑：哦，我读错了，你只需要在排除符号+幅度之后生成该值，所以

说实话，如果我听起来有点麻木 Posix 定义了一个整数类型，但没有为它们提供限制，我可能会采用旧的“移植标头”方法，将可能在任何地方都可以工作的东西放在标头中，并记录下来。与他们通常必须做的事情相比，他们可能会在任何奇怪的实现上编译代码之前检查它，他们会很高兴地接受这一点。

Answer 6

从技术上讲，它不是一个宏，但实际上，以下内容应始终折叠为 off_t 或任何有符号类型的常量最小值，无论符号表示如何。虽然我不确定什么不需要两个人的恭维，如果有的话。

POSIX 要求 off_t 使用有符号整数类型，因此 C99 有符号精确宽度值应该足够了。有些平台实际上定义了 OFF_T_MIN (OSX)，但不幸的是 POSIX 并不需要它。

#include <stdint.h>
#include <assert.h>

#include <sys/types.h>

  assert(sizeof(off_t) >= sizeof(int8_t) && sizeof(off_t) <= sizeof(intmax_t));

  const off_t OFF_T_MIN = sizeof(off_t) == sizeof(int8_t)   ? INT8_MIN    :
                          sizeof(off_t) == sizeof(int16_t)  ? INT16_MIN   :
                          sizeof(off_t) == sizeof(int32_t)  ? INT32_MIN   :
                          sizeof(off_t) == sizeof(int64_t)  ? INT64_MIN   :
                          sizeof(off_t) == sizeof(intmax_t) ? INTMAX_MIN  : 0;

同样可用于获得最大值。

  assert(sizeof(off_t) >= sizeof(int8_t) && sizeof(off_t) <= sizeof(intmax_t));

  const off_t OFF_T_MAX = sizeof(off_t) == sizeof(int8_t)   ? INT8_MAX    :
                          sizeof(off_t) == sizeof(int16_t)  ? INT16_MAX   :
                          sizeof(off_t) == sizeof(int32_t)  ? INT32_MAX   :
                          sizeof(off_t) == sizeof(int64_t)  ? INT64_MAX   :
                          sizeof(off_t) == sizeof(intmax_t) ? INTMAX_MAX  : 0;

不过，可以使用 autoconf 或 cmake 将其转换为宏。

Answer 7

从 C11 开始，您可以使用 _Generic 来查找基础类型。在此之前，带有 __typeof 和 __builtin_types_known_p 的 __builtin_choose_expr 是相当可移植的。

如果您不想使用其中任何一个，您可以根据其大小和符号来猜测类型。

#include <stdio.h>
#include <limits.h>
#define TP_MAX(Tp) ((Tp)-1>0 ? ( \
                        1==sizeof(Tp) ? ((Tp)2==1?1:UCHAR_MAX) \
                        : sizeof(unsigned short)==sizeof(Tp) ? USHRT_MAX \
                        : sizeof(unsigned int)==sizeof(Tp) ? UINT_MAX \
                        : sizeof(unsigned long)==sizeof(Tp) ? ULONG_MAX \
                        : sizeof(unsigned long long)==sizeof(Tp) ? ULLONG_MAX : 0 \
                   ) :  ( 1==sizeof(Tp) ? SCHAR_MAX \
                        : sizeof(short)==sizeof(Tp) ? SHRT_MAX \
                        : sizeof(int)==sizeof(Tp) ? INT_MAX \
                        : sizeof(long)==sizeof(Tp) ? LONG_MAX \
                        : sizeof(long long)==sizeof(Tp) ? LLONG_MAX : 0)) \


#define STC_ASSERT(X) ((void)(sizeof(struct { int stc_assert:(X)?1:-1; })))

int main()
{
    STC_ASSERT(TP_MAX(signed char)==SCHAR_MAX);
    STC_ASSERT(TP_MAX(short)==SHRT_MAX);
    STC_ASSERT(TP_MAX(int)==INT_MAX);
    STC_ASSERT(TP_MAX(long)==LONG_MAX);
    STC_ASSERT(TP_MAX(long long)==LLONG_MAX);
    STC_ASSERT(TP_MAX(unsigned char)==UCHAR_MAX);
    STC_ASSERT(TP_MAX(unsigned short)==USHRT_MAX);
    STC_ASSERT(TP_MAX(unsigned int)==UINT_MAX);
    STC_ASSERT(TP_MAX(unsigned long)==ULONG_MAX);
    STC_ASSERT(TP_MAX(unsigned long long)==ULLONG_MAX);
}

（如果您想在没有限制的情况下执行此操作，请查看我的答案 https://stackoverflow.com/a/53470064 /1084774）。

Answer 8

TL;DR：使用下面列出的头文件，然后使用 TYPE_MAX(someType) 获取 someType 使用的类型的最大值。

您可以使用 C11 中引入的 _Generic 表达式。
您需要编译器支持的每个基本整数类型（例如 char、long 等）的列表，以及每个类型定义的整数（最有可能的是 uint8_t< /code>, off_t) 将被视为基础类型。

下面是一个示例头文件：

#include <float.h>
#include <limits.h>
#include <stdint.h>
#include <stdbool.h>

#if UINTMAX_MAX==ULLONG_MAX
  #define TYPE_UINTMAX_MAX
  #define TYPE_UINTMAX_MIN
#else  //UINTMAX_MAX!=ULLONG_MAX
  #define TYPE_UINTMAX_MAX                    \
      , uintmax_t           : UINTMAX_MAX     \
      , intmax_t            : INTMAX_MAX      \

  #define TYPE_UINTMAX_MIN                    \
      , uintmax_t           : UINTMAX_MIN     \
      , intmax_t            : INTMAX_MIN      \

#endif //UINTMAX_MAX==ULLONG_MAX


#define TYPE_MAX(variable) _Generic          \
  (                                          \
    (variable)                               \
    , bool                : 1                \
    , char                : CHAR_MAX         \
    , unsigned char       : UCHAR_MAX        \
    , signed   char       : SCHAR_MAX        \
    , unsigned short      : USHRT_MAX        \
    , signed   short      : SHRT_MAX         \
    , unsigned int        : UINT_MAX         \
    , signed   int        : INT_MAX          \
    , unsigned long       : ULONG_MAX        \
    , signed   long       : LONG_MAX         \
    , unsigned long long  : ULLONG_MAX       \
    , signed   long long  : LLONG_MAX        \
    TYPE_UINTMAX_MAX                         \
                                             \
    , float               : FLT_MAX          \
    , double              : DBL_MAX          \
    , long double         : LDBL_MAX         \
  )

#define TYPE_MIN(variable) _Generic          \
  (                                          \
    (variable)                               \
    , bool                : 0                \
    , char                : CHAR_MIN         \
    , unsigned char       : 0                \
    , signed   char       : SCHAR_MIN        \
    , unsigned short      : 0                \
    , signed   short      : SHRT_MIN         \
    , unsigned int        : 0                \
    , signed   int        : INT_MIN          \
    , unsigned long       : 0                \
    , signed   long       : LONG_MIN         \
    , unsigned long long  : 0                \
    , signed   long long  : LLONG_MIN        \
    TYPE_UINTMAX_MIN                         \
                                             \
    , float               : -FLT_MAX         \
    , double              : -DBL_MAX         \
    , long double         : -LDBL_MAX        \
  )

假设 off_t 是用 typedef int64_t off_t 定义的，而 int64_t 是用 typedef long long int64_t< 定义的/code>，那么C编译器将处理off_t foo; TYPE_MAX(foo) 与 long long foo 相同； TYPE_MAX(foo) 并将选择值为 LLONG_MAX 的选项，为您提供最大值。

如果系统具有此头文件中未列出的其他本机类型，请创建一个预处理器变量，该变量在其他系统上为空，但在使用该类型的系统上进行编译时包含该本机类型的值。然后将此预处理器变量添加到列表中，类似于此处使用 uintmax_t 完成的操作。

Answer 9

我使用以下模式来解决问题（假设没有填充位）：

((((type) 1 << (number_of_bits_in_type - 2)) - 1) << 1) + 1

number_of_bits_in_type 派生为 CHAR_BIT * sizeof (type)，如其他答案中所示。

我们基本上将 1 位“推”到位，同时避免符号位。

您可以看到这是如何工作的。假设宽度为16位。然后我们将 1 左移 16 - 2 = 14，生成位模式 0100000000000000。我们小心翼翼地避免将 1 移入符号位。接下来，我们从中减去 1，得到 0011111111111111。看看这是怎么回事？我们将其左移 1，得到 0111111111111110，再次避免符号位。最后加1，得到0111111111111111，这是最高的有符号16位值。

如果你在博物馆工作，那里有这样的东西，那么这在补码和符号数值机器上应该可以很好地工作。如果你有填充位，它就不起作用。为此，您可能所能做的就是#ifdef，或者切换到编译器和预处理器之外的替代配置机制。

因此，对于 off_t：

// probably bad idea to use these symbol names

#define OFF_T_BITS (sizeof (off_t) * CHAR_BIT)
#define OFF_T_MAX (((((off_t) 1 << (OFF_T_BITS - 2)) - 1) << 1) + 1)

Answer 10

您可能想查看 limit.h （在 C99 中添加），该标头提供了应设置为匹配编译器范围的宏。 （它与编译器附带的标准库一起提供，或者第三方标准库替换负责使其正确）