如何在C中打印int64\t类型

C99标准具有整数类型，其字节大小与int64\t类似。我正在使用以下代码：

#include <stdio.h>
#include <stdint.h>
int64_t my_int = 999999999999999999;
printf("This is my_int: %I64d\n", my_int);

我试过：

printf("This is my_int: %lld\n", my_int); // long long decimal

但我得到了同样的警告。我正在使用此编译器：

~/dev/c$ cc -v
Using built-in specs.
Target: i686-apple-darwin10
Configured with: /var/tmp/gcc/gcc-5664~89/src/configure --disable-checking --enable-werror --prefix=/usr --mandir=/share/man --enable-languages=c,objc,c++,obj-c++ --program-transform-name=/^[cg][^.-]*$/s/$/-4.2/ --with-slibdir=/usr/lib --build=i686-apple-darwin10 --program-prefix=i686-apple-darwin10- --host=x86_64-apple-darwin10 --target=i686-apple-darwin10 --with-gxx-include-dir=/include/c++/4.2.1
Thread model: posix
gcc version 4.2.1 (Apple Inc. build 5664)

在没有警告的情况下，我应该使用哪种格式打印我的int变量？

C99方式是

#include <inttypes.h>
int64_t my_int = 999999999999999999;
printf("%" PRId64 "\n", my_int);

---

如果您一直使用C89实现（特别是Visual Studio），您可能可以使用开源的

（和

）：

在windows环境中，使用

%I64d

在Linux中，使用

%lld

---

对于

int64\t

类型：

#include <inttypes.h>
int64_t t;
printf("%" PRId64 "\n", t);

#include <inttypes.h>
uint64_t t;
printf("%" PRIu64 "\n", t);

您还可以使用

PRIx64

以十六进制打印

所有类型的可用宏，包括

intptr\u t

（

PRIxPTR

）。scanf有单独的宏，如

SCNd64

---

PRIu16的典型定义是

“hu”

，因此隐式字符串常量连接在编译时发生

---

要使代码完全可移植，必须使用

PRId32

等打印

int32\t

，以及

%d

或类似工具，用于使用C99打印

int
，
%j
长度修饰符也可以与printf系列函数一起使用，以打印
int64\t
和
uint64\t
类型的值：

#include <stdio.h>
#include <stdint.h>

int main(int argc, char *argv[])
{
    int64_t  a = 1LL << 63;
    uint64_t b = 1ULL << 63;

    printf("a=%jd (0x%jx)\n", a, a);
    printf("b=%ju (0x%jx)\n", b, b);

    return 0;
}

这是根据我的Linux系统上的
printf（3）
（手册页特别指出，
j
用于表示转换为
intmax\u t
或
uintmax\u t
；在我的stdint.h中，
int64\u t
和
intmax\u t
的类型定义方式完全相同，对于
uint64\u t
）。我不确定这是否可以完美地移植到其他系统。
来自嵌入式世界，即使uclibc也不总是可用，并且类似于

uint64\u t myval=0xdeadfacedeadbeef；
printf（“%llx”，myval）；

是打印你的垃圾还是根本不工作--我总是使用一个小助手，它允许我正确地转储uint64\u t hex：

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>

char* ullx(uint64_t val)
{
    static char buf[34] = { [0 ... 33] = 0 };
    char* out = &buf[33];
    uint64_t hval = val;
    unsigned int hbase = 16;

    do {
        *out = "0123456789abcdef"[hval % hbase];
        --out;
        hval /= hbase;
    } while(hval);

    *out-- = 'x', *out = '0';

    return out;
}

#包括
#包括
#包括
字符*ullx（uint64_t val）
{
静态字符buf[34]={[0…33]=0}；
char*out=&buf[33]；
uint64_t hval=val；
无符号整数hbase=16；
做{
*out=“0123456789abcdef”[hval%hbase]；
--出去；
hval/=hbase；
}while（hval）；
*out--='x'，*out='0'；
返回；
}
//VC6.0（386及更高版本）

关于。
如果
%jd
请求一个
intmax\t
，正确的调用应该是
printf（“a=%jd（0x%jx）”，（intmax\t）a，（intmax\t）a）
。不能保证
int64_t
和
intmax_t
是同一类型，如果不是，行为是未定义的。如果在将它们传递到
printf
：
printf（“jd=%a\n”）之前将它们显式转换为
intmax_t
，则可以移植使用
%jd
打印
值，（intmax_t）a）
。这避免了（IMHO）
宏的丑陋。当然，这假设您的实现支持
%jd
、
int64\u t
、和
intmax\u t
，所有这些都是由C99添加的。@KeithThompson的“丑陋”是把它说得太友好了。它绝对可怕。它令人恶心。令人尴尬的是什么是的。或者至少他们应该感到尴尬，引入这个的很多人。我从来没有见过这些宏，但按照这个答案和你的评论（包括你的评论）所建议的去做。@Pryftan我觉得它们没有你想象的那么丑陋——我根本不知道如何在不改变语言的情况下以不那么丑陋的方式定义它们。@KeithThompson Wel我很感激你至少对“相当”这个词很有压力。其实这没关系。我不明白为什么宏必须在那里。你说你可以携带……但是我也发现关键字的数量也增加了。格式化宏常量的完整列表：如果在Linux上使用C++，则是。在包含
inttypes之前，一定要定义
\u STDC\u FORMAT\u宏
。h
PRId64
是一个内部翻译为
“lld”
的宏。因此，它与编写
printf（“lld\n”，t）一样好
请参见说明：@Gaurav，这在某些平台上是正确的，但并非在所有平台上都是正确的。例如，在我的amd64 Linux机器上，PRId64被定义为
ld
。宏的原因是可移植性。我认为，通过一些额外的努力，他们可能会让它变得更讨厌
%lld
是
long int
的格式不一定与
int64_t
相同
有一个宏，用于
int64_t
的正确格式；请参阅。@KeithThompson但是，由于
long-long
至少是64位，
printf（“%lld”，（long-long）x）；
应该可以工作，除了-0x80000000000000之外，如果该类型没有使用二的补码，它就不能表示为
long
。@PascalCuoq:是的，它应该可以与强制转换一起工作（您提到的例外情况不太可能发生，仅适用于支持两位补码的系统，但不用于
long
）当使用来自CODE.GoGoLe.Link的MsTyType时，我需要定义C++的STDC*FALATATHMULTS。请参见“AcsCRIIS”。看起来宏只不过是C++所需要的。链接到的代码中的定义是在一个<代码>中，如果定义的话（α-CPLUS）定义了（Sy-STDC*FrimaTy宏）。对于C++，如果你面对嵌入式应用程序的这个问题，那么这就是你要找的。这个解决方案对我来说是有效的。
#include <stdio.h>
#include <stdint.h>

int main(int argc, char *argv[])
{
    int64_t  a = 1LL << 63;
    uint64_t b = 1ULL << 63;

    printf("a=%jd (0x%jx)\n", a, a);
    printf("b=%ju (0x%jx)\n", b, b);

    return 0;
}

a=-9223372036854775808 (0x8000000000000000)
b=9223372036854775808 (0x8000000000000000)

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>

char* ullx(uint64_t val)
{
    static char buf[34] = { [0 ... 33] = 0 };
    char* out = &buf[33];
    uint64_t hval = val;
    unsigned int hbase = 16;

    do {
        *out = "0123456789abcdef"[hval % hbase];
        --out;
        hval /= hbase;
    } while(hval);

    *out-- = 'x', *out = '0';

    return out;
}

    __int64 my_qw_var = 0x1234567890abcdef;

    __int32 v_dw_h;
    __int32 v_dw_l;

    __asm
        {
            mov eax,[dword ptr my_qw_var + 4]   //dwh
            mov [dword ptr v_dw_h],eax

            mov eax,[dword ptr my_qw_var]   //dwl
            mov [dword ptr v_dw_l],eax

        }
        //Oops 0.8 format
    printf("val = 0x%0.8x%0.8x\n", (__int32)v_dw_h, (__int32)v_dw_l);