我想知道确定打印小数的最大字符数是否是一种简单的方法int。
我知道<limits.h>包含这样的定义，即 int 可以假设的INT_MAX最大值，但这不是我想要的。
我希望能够做类似的事情：
int get_int( void )
{
char draft[ MAX_CHAR_OF_A_DECIMAL_INT ];
fgets( draft, sizeof( draft ), stdin );
return strtol( draft, NULL, 10 );
}
但是如何以MAX_CHAR_OF_A_DECIMAL_INT可移植和低开销的方式找到 的价值呢？
谢谢！
如果您假设CHAR_BIT是 8（POSIX 需要，因此对于任何针对 POSIX 系统以及任何其他主流系统（如 Windows）的代码都是一个安全的假设），一个便宜的安全公式是3*sizeof(int)+2. 如果没有，您可以制作它3*sizeof(int)*CHAR_BIT/8+2，或者有一个稍微简单的版本。
如果您对它起作用的原因感兴趣，sizeof(int)它本质上是INT_MAX（大约以 2^CHAR_BIT 为底的对数）的对数，并且不同底数的对数之间的转换（例如以 10 为底）只是乘法。特别是，3 是对数基数 10 的整数近似值/上限，即 256。
+2 是为了说明可能的符号和空终止。
最简单的规范和可以说是最便携的方法是询问snprintf()需要多少空间：
char sbuf[2];
int ndigits;
ndigits = snprintf(sbuf, (size_t) 1, "%lld", (long long) INT_MIN);
稍微不那么便携可能使用intmax_tand %j：
ndigits = snprintf(sbuf, (size_t) 1, "%j", (intmax_t) INT_MIN);
人们可能会认为在运行时这样做太昂贵了，但它可以用于任何值，而不仅仅是任何整数类型的 MIN/MAX 值。
当然，您也可以使用简单的递归函数直接计算给定整数需要以 Base 10 表示法表示的位数：
unsigned int
numCharsB10(intmax_t n)
{
if (n < 0)
return numCharsB10((n == INTMAX_MIN) ? INTMAX_MAX : -n) + 1;
if (n < 10)
return 1;
return 1 + numCharsB10(n / 10);
}
但这当然也需要在运行时使用 CPU，即使是内联时也是如此，尽管可能比实际少一点snprintf()。
@R. 上面的答案虽然或多或少是错误的，但在正确的轨道上。下面是一些非常好、经过广泛测试和高度可移植的宏的正确推导，它们在编译时使用 实现计算sizeof()，使用对@R. 的初始措辞进行轻微修正开始：
首先，我们可以很容易地看到（或显示）它sizeof(int)是以 2 为底UINT_MAX的对数除以sizeof()(8, aka CHAR_BIT) 的一个单位表示的位数：
sizeof(int) == log2(UINT_MAX) / 8
因为UINT_MAX当然只是 2 ^ (sizeof(int) * 8)) 而 log2(x) 是 2^x 的倒数。
我们可以使用恒等式“logb(x) = log(x) / log(b)”（其中 log() 是自然对数）来求其他底的对数。例如，您可以使用以下方法计算“x”的“log base 2”：
log2(x) = log(x) / log(2)
并且：
log10(x) = log(x) / log(10)
所以，我们可以推断：
log10(v) = log2(v) / log2(10)
现在我们最终想要的是 的以 10 为底的对数UINT_MAX，所以由于 log2(10) 大约是 3，并且由于我们从上面知道 log2() 是关于 的sizeof()，所以我们可以说 log10( UINT_MAX) 大约是：
log10(2^(sizeof(int)*8)) ~= (sizeof(int) * 8) / 3
虽然这并不完美，特别是因为我们真正想要的是上限值，但是通过一些小的调整来考虑 log2(10) 到 3 的整数舍入，我们可以通过首先在 log2 项上加一个来得到我们需要的东西，然后从任何较大整数的结果中减去 1，得到这个“足够好”的表达式：
#if 0
#define __MAX_B10STRLEN_FOR_UNSIGNED_TYPE(t) \
((((sizeof(t) * CHAR_BIT) + 1) / 3) - ((sizeof(t) > 2) ? 1 : 0))
#endif
更好的是，我们可以将第一个 log2() 项乘以 1/log2(10)（乘以除数的倒数与除数相同），这样做可以找到更好的整数近似值。我最近（重新？）在阅读肖恩安德森的比特黑客时遇到了这个建议：http: //graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
为了尽可能地使用整数数学来做到这一点，我们需要找到代表我们倒数的理想比率。这可以通过搜索将我们期望的值 1/log2(10) 乘以 2 的连续幂的最小小数部分来找到，在 2 的某个合理范围内，例如使用以下小 AWK 脚本：
awk 'BEGIN {
minf=1.0
}
END {
for (i = 1; i <= 31; i++) {
a = 1.0 / (log(10) / log(2)) * 2^i
if (a > (2^32 / 32))
break;
n = int(a)
f = a - (n * 1.0)
if (f < minf) {
minf = f
minn = n
bits = i
}
# printf("a=%f, n=%d, f=%f, i=%d\n", a, n, f, i)
}
printf("%d + %f / %d, bits=%d\n", minn, minf, 2^bits, bits)
}' < /dev/null
1233 + 0.018862 / 4096, bits=12
所以我们可以得到一个很好的整数近似值，将我们的 log2(v) 值乘以 1/log2(10)，方法是将它乘以 1233，然后右移 12（当然，2^12 是 4096）：
log10(UINT_MAX) ~= ((sizeof(int) * 8) + 1) * 1233 >> 12
并且，加上加一个来做相当于找到上限值的操作，这消除了摆弄奇数值的需要：
#define __MAX_B10STRLEN_FOR_UNSIGNED_TYPE(t) \
(((((sizeof(t) * CHAR_BIT)) * 1233) >> 12) + 1)
/*
* for signed types we need room for the sign, except for int64_t
*/
#define __MAX_B10STRLEN_FOR_SIGNED_TYPE(t) \
(__MAX_B10STRLEN_FOR_UNSIGNED_TYPE(t) + ((sizeof(t) == 8) ? 0 : 1))
/*
* NOTE: this gives a warning (for unsigned types of int and larger) saying
* "comparison of unsigned expression < 0 is always false", and of course it
* is, but that's what we want to know (if indeed type 't' is unsigned)!
*/
#define __MAX_B10STRLEN_FOR_INT_TYPE(t) \
(((t) -1 < 0) ? __MAX_B10STRLEN_FOR_SIGNED_TYPE(t) \
: __MAX_B10STRLEN_FOR_UNSIGNED_TYPE(t))
而通常编译器将在编译时评估我的__MAX_B10STRLEN_FOR_INT_TYPE()宏变成的表达式。当然，我的宏总是计算给定类型整数所需的最大空间，而不是特定整数值所需的确切空间。
我不知道在普通的 ANSI-C 中做你想做的事是否有任何技巧，但在 C++ 中，你可以轻松地使用模板元编程来做：
#include <iostream>
#include <limits>
#include <climits>
template< typename T, unsigned long N = INT_MAX >
class MaxLen
{
public:
enum
{
StringLen = MaxLen< T, N / 10 >::StringLen + 1
};
};
template< typename T >
class MaxLen< T, 0 >
{
public:
enum
{
StringLen = 1
};
};
您可以从纯 C 代码中调用它，创建一个额外的 C++ 函数，如下所示：
extern "C"
int int_str_max( )
{
return MaxLen< int >::StringLen;
}
这具有零执行时间开销并计算所需的确切空间。
您可以使用以下内容测试上述模板：
int main( )
{
std::cout << "Max: " << std::numeric_limits< short >::max( ) << std::endl;
std::cout << "Digits: " << std::numeric_limits< short >::digits10 << std::endl;
std::cout << "A \"short\" is " << sizeof( short ) << " bytes." << std::endl
<< "A string large enough to fit any \"short\" is "
<< MaxLen< short, SHRT_MAX >::StringLen << " bytes wide." << std::endl;
std::cout << "Max: " << std::numeric_limits< int >::max( ) << std::endl;
std::cout << "Digits: " << std::numeric_limits< int >::digits10 << std::endl;
std::cout << "An \"int\" is " << sizeof( int ) << " bytes." << std::endl
<< "A string large enough to fit any \"int\" is "
<< MaxLen< int >::StringLen << " bytes wide." << std::endl;
std::cout << "Max: " << std::numeric_limits< long >::max( ) << std::endl;
std::cout << "Digits: " << std::numeric_limits< long >::digits10 << std::endl;
std::cout << "A \"long\" is " << sizeof( long ) << " bytes." << std::endl
<< "A string large enough to fit any \"long\" is "
<< MaxLen< long, LONG_MAX >::StringLen << " bytes wide." << std::endl;
return 0;
}
输出是：
Max: 32767
Digits: 4
A "short" is 2 bytes.
A string large enough to fit any "short" is 6 bytes wide.
Max: 2147483647
Digits: 9
An "int" is 4 bytes.
A string large enough to fit any "int" is 11 bytes wide.
Max: 9223372036854775807
Digits: 18
A "long" is 8 bytes.
A string large enough to fit any "long" is 20 bytes wide.
std::numeric_limits< T >::digits10，因为如果无法达到“9”，则前者不考虑数字。当然，如果您不想在某些情况下浪费一个字节，您当然可以使用它并简单地添加两个。编辑：
有些人可能觉得很奇怪，包括<climits>. 如果您可以使用 C++11，您将不需要它，并且会获得额外的简单性：
#include <iostream>
#include <limits>
template< typename T, unsigned long N = std::numeric_limits< T >::max( ) >
class MaxLen
{
public:
enum
{
StringLen = MaxLen< T, N / 10 >::StringLen + 1
};
};
template< typename T >
class MaxLen< T, 0 >
{
public:
enum
{
StringLen = 1
};
};
现在你可以使用
MaxLen< short >::StringLen
代替
MaxLen< short, SHRT_MAX >::StringLen
很好，不是吗？
b位的有符号或无符号整数x的最大十进制位数d与数字 2^ b的十进制位数匹配。对于带符号的数字，必须为符号添加一个额外的字符。
x的小数位数可以计算为 log_10( x )，四舍五入。
因此， x的最大小数位数将为 log_10(2^ b ) = b * log_10(2) = b * 0.301029995663981，四舍五入。
如果s是用于存储x的某种整数类型的字节大小（由sizeof运算符给出） ，则其大小b（以位为单位）将为b = s * 8。因此，十进制数字的最大位数d将是 ( s * 8) * 0.301029995663981，四舍五入。向上取整将包括截断（转换为整数）和加 1。
当然，所有这些常量都必须加 1 才能计算最后的 0 字节（请参阅以下示例中的 IntegerString）。
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#define COMMON_LOG_OF_2 0.301029995663981
#define MAX_DECIMAL_DIGITS_UCHAR ((unsigned) (sizeof (unsigned char ) * 8 * COMMON_LOG_OF_2) + 1)
#define MAX_DECIMAL_DIGITS_USHORT ((unsigned) (sizeof (unsigned short ) * 8 * COMMON_LOG_OF_2) + 1)
#define MAX_DECIMAL_DIGITS_UINT ((unsigned) (sizeof (unsigned int ) * 8 * COMMON_LOG_OF_2) + 1)
#define MAX_DECIMAL_DIGITS_ULONG ((unsigned) (sizeof (unsigned long ) * 8 * COMMON_LOG_OF_2) + 1)
#define MAX_DECIMAL_DIGITS_ULONGLONG ((unsigned) (sizeof (unsigned long long) * 8 * COMMON_LOG_OF_2) + 1)
#define MAX_DECIMAL_DIGITS_UINT128 ((unsigned) (sizeof (unsigned __int128 ) * 8 * COMMON_LOG_OF_2) + 1)
#define MAX_DECIMAL_DIGITS_CHAR (1 + MAX_DECIMAL_DIGITS_UCHAR )
#define MAX_DECIMAL_DIGITS_SHORT (1 + MAX_DECIMAL_DIGITS_USHORT )
#define MAX_DECIMAL_DIGITS_INT (1 + MAX_DECIMAL_DIGITS_UINT )
#define MAX_DECIMAL_DIGITS_LONG (1 + MAX_DECIMAL_DIGITS_ULONG )
#define MAX_DECIMAL_DIGITS_LONGLONG (1 + MAX_DECIMAL_DIGITS_ULONGLONG)
#define MAX_DECIMAL_DIGITS_INT128 (1 + MAX_DECIMAL_DIGITS_UINT128 )
int main (void)
{
char IntegerString[MAX_DECIMAL_DIGITS_INT + 1];
printf ("MAX_DECIMAL_DIGITS_UCHAR = %2u\n",MAX_DECIMAL_DIGITS_UCHAR );
printf ("MAX_DECIMAL_DIGITS_USHORT = %2u\n",MAX_DECIMAL_DIGITS_USHORT );
printf ("MAX_DECIMAL_DIGITS_UINT = %2u\n",MAX_DECIMAL_DIGITS_UINT );
printf ("MAX_DECIMAL_DIGITS_ULONG = %2u\n",MAX_DECIMAL_DIGITS_ULONG );
printf ("MAX_DECIMAL_DIGITS_ULONGLONG = %2u\n",MAX_DECIMAL_DIGITS_ULONGLONG);
printf ("MAX_DECIMAL_DIGITS_UINT128 = %2u\n",MAX_DECIMAL_DIGITS_UINT128 );
printf ("MAX_DECIMAL_DIGITS_CHAR = %2u\n",MAX_DECIMAL_DIGITS_CHAR );
printf ("MAX_DECIMAL_DIGITS_SHORT = %2u\n",MAX_DECIMAL_DIGITS_SHORT );
printf ("MAX_DECIMAL_DIGITS_INT = %2u\n",MAX_DECIMAL_DIGITS_INT );
printf ("MAX_DECIMAL_DIGITS_LONG = %2u\n",MAX_DECIMAL_DIGITS_LONG );
printf ("MAX_DECIMAL_DIGITS_LONGLONG = %2u\n",MAX_DECIMAL_DIGITS_LONGLONG );
printf ("MAX_DECIMAL_DIGITS_INT128 = %2u\n",MAX_DECIMAL_DIGITS_INT128 );
sprintf (IntegerString,"%d",INT_MAX);
printf ("INT_MAX = %d\n",INT_MAX);
printf ("IntegerString = %s\n",IntegerString);
sprintf (IntegerString,"%d",INT_MIN);
printf ("INT_MIN = %d\n",INT_MIN);
printf ("IntegerString = %s\n",IntegerString);
return EXIT_SUCCESS;
}
编辑：
不幸的是，在将表达式计算为常量时，使用浮点可能会导致问题。我已经通过乘以 2 ^ 11 并除以 2 ^ 8 来修改它们，因此所有计算都应该由预处理器使用整数执行：
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#define LOG2_x_2_11 616 // log(2) * 2^11
#define MAX_DECIMAL_DIGITS_UCHAR (((sizeof (unsigned char ) * LOG2_x_2_11) >> 8) + 1)
#define MAX_DECIMAL_DIGITS_USHORT (((sizeof (unsigned short ) * LOG2_x_2_11) >> 8) + 1)
#define MAX_DECIMAL_DIGITS_UINT (((sizeof (unsigned int ) * LOG2_x_2_11) >> 8) + 1)
#define MAX_DECIMAL_DIGITS_ULONG (((sizeof (unsigned long ) * LOG2_x_2_11) >> 8) + 1)
#define MAX_DECIMAL_DIGITS_ULONGLONG (((sizeof (unsigned long long) * LOG2_x_2_11) >> 8) + 1)
#define MAX_DECIMAL_DIGITS_UINT128 (((sizeof (unsigned __int128 ) * LOG2_x_2_11) >> 8) + 1)
#define MAX_DECIMAL_DIGITS_CHAR (1 + MAX_DECIMAL_DIGITS_UCHAR )
#define MAX_DECIMAL_DIGITS_SHORT (1 + MAX_DECIMAL_DIGITS_USHORT )
#define MAX_DECIMAL_DIGITS_INT (1 + MAX_DECIMAL_DIGITS_UINT )
#define MAX_DECIMAL_DIGITS_LONG (1 + MAX_DECIMAL_DIGITS_ULONG )
#define MAX_DECIMAL_DIGITS_LONGLONG (1 + MAX_DECIMAL_DIGITS_ULONGLONG)
#define MAX_DECIMAL_DIGITS_INT128 (1 + MAX_DECIMAL_DIGITS_UINT128 )
int main (void)
{
char IntegerString[MAX_DECIMAL_DIGITS_INT + 1];
printf ("MAX_DECIMAL_DIGITS_UCHAR = %2zu\n",MAX_DECIMAL_DIGITS_UCHAR );
printf ("MAX_DECIMAL_DIGITS_USHORT = %2zu\n",MAX_DECIMAL_DIGITS_USHORT );
printf ("MAX_DECIMAL_DIGITS_UINT = %2zu\n",MAX_DECIMAL_DIGITS_UINT );
printf ("MAX_DECIMAL_DIGITS_ULONG = %2zu\n",MAX_DECIMAL_DIGITS_ULONG );
printf ("MAX_DECIMAL_DIGITS_ULONGLONG = %2zu\n",MAX_DECIMAL_DIGITS_ULONGLONG);
printf ("MAX_DECIMAL_DIGITS_UINT128 = %2zu\n",MAX_DECIMAL_DIGITS_UINT128 );
printf ("MAX_DECIMAL_DIGITS_CHAR = %2zu\n",MAX_DECIMAL_DIGITS_CHAR );
printf ("MAX_DECIMAL_DIGITS_SHORT = %2zu\n",MAX_DECIMAL_DIGITS_SHORT );
printf ("MAX_DECIMAL_DIGITS_INT = %2zu\n",MAX_DECIMAL_DIGITS_INT );
printf ("MAX_DECIMAL_DIGITS_LONG = %2zu\n",MAX_DECIMAL_DIGITS_LONG );
printf ("MAX_DECIMAL_DIGITS_LONGLONG = %2zu\n",MAX_DECIMAL_DIGITS_LONGLONG );
printf ("MAX_DECIMAL_DIGITS_INT128 = %2zu\n",MAX_DECIMAL_DIGITS_INT128 );
sprintf (IntegerString,"%d",INT_MAX);
printf ("INT_MAX = %d\n",INT_MAX);
printf ("IntegerString = %s\n",IntegerString);
sprintf (IntegerString,"%d",INT_MIN);
printf ("INT_MIN = %d\n",INT_MIN);
printf ("IntegerString = %s\n",IntegerString);
return EXIT_SUCCESS;
}
接受答案后（2 年以上）
以下分数 10/33 完全满足未填充int8_t、int16_t和int32_t的需求int128_t。只有 1 个char额外的int64_t。精确或大于 1 的所有整数大小直到int362_t. 除此之外可能超过1。
#include <limits.h>
#define MAX_CHAR_LEN_DECIMAL_INTEGER(type) (10*sizeof(type)*CHAR_BIT/33 + 2)
#define MAX_CHAR_SIZE_DECIMAL_INTEGER(type) (10*sizeof(type)*CHAR_BIT/33 + 3)
int get_int( void ) {
// + 1 for the \n of fgets()
char draft[MAX_CHAR_SIZE_DECIMAL_INTEGER(long) + 1]; //**
fgets(draft, sizeof draft, stdin);
return strtol(draft, NULL, 10);
}
**fgets()通常最好使用附加char的终止'\n'.
类似于@R..但分数更好。
推荐在读取用户输入时使用大容量的 2x 缓冲区。有时用户会添加空格、前导零等。
char draft[2*(MAX_CHAR_SIZE_DECIMAL_INTEGER(long) + 1)];
fgets(draft, sizeof draft, stdin);
您可以使用以 10 为底的对数来计算位数。在我的系统中，使用数字的位表示来计算以 2 为底的对数上限并没有显着提高速度。对数基数 10 + 1 的底给出了位数，我加 2 来说明空字符和符号。
#include <limits.h>
#include <stdio.h>
#include <math.h>
int main(void){
printf("%d %d\n", INT_MAX, (int)floor(log10(INT_MAX)) + 3);
return 0;
}
另请注意，an 的字节数int可以是 2 或 4，并且仅在旧系统中为 2，因此您可以计算上限并在程序中使用它。
在 C++11 及更高版本中，您可以执行以下操作：
namespace details {
template<typename T>
constexpr size_t max_to_string_length_impl(T value) {
return (value >= 0 && value < 10) ? 1 // [0..9] -> 1
: (std::is_signed<T>::value && value < 0 && value > -10) ? 2 // [-9..-1] -> 2
: 1 + max_to_string_length_impl(value / 10); // ..-10] [10.. -> recursion
}
}
template<typename T>
constexpr size_t max_to_string_length() {
return std::max(
details::max_to_string_length_impl(std::numeric_limits<T>::max()),
details::max_to_string_length_impl(std::numeric_limits<T>::min()));
}
这是C版本：
#include <limits.h>
#define xstr(s) str(s)
#define str(s) #s
#define INT_STR_MAX sizeof(xstr(INT_MAX))
char buffer[INT_STR_MAX];
然后：
$ gcc -E -o str.cpp str.c
$ grep buffer str.cpp
char buffer[sizeof("2147483647")];
$ gcc -S -o str.S str.c
$ grep buffer str.S
.comm buffer,11,1