63

If I have an integer variable I can use sscanf as shown below by using the format specifier %d.

sscanf (line, "Value of integer: %d\n", &my_integer);

Where can I find format specifiers for uint8_t, uint16_t, uint32_t and uint64_t?

uint64_t has probably %lu.

Improve this question
5
  • Isn't %lu for unsigned long? That's often 32 bits. Commented Aug 9, 2011 at 8:10
  • 5
    No problem if you use iostreams instead, which adapt to the type Commented Aug 9, 2011 at 8:14
  • 1
    @MSalters: beware that for 64 bits targets, Windows 64 unsigned long is 32 bits, whereas all UNIX and Linux 64 bits unsigned long are 64 bits. Commented Aug 9, 2011 at 8:47
  • 3
    @Didier Trosset unsigned long is NOT 64 bit on all 64 bit UNIX variants. It's 32 bits on 64 bit solaris using gcc. I once had a painful experience learning that it's 64bits on linux. Commented Feb 17, 2013 at 16:06
  • @camelccc From what is explained there: unix.org/version2/whatsnew/lp64_wp.html, 64 bit solaris ought to be an exception to UNIX being LP64. Commented Feb 18, 2013 at 7:44

7 Answers 7

Reset to default
99

They are declared in <inttypes.h> as macros: SCNd8, SCNd16, SCNd32 and SCNd64. Example (for int32_t):

sscanf (line, "Value of integer: %" SCNd32 "\n", &my_integer);

Their format is PRI (for printf)/SCN (for scan) then o, u, x, X d, i for the corresponding specifier then nothing, LEAST, FAST, MAX then the size (obviously there is no size for MAX). Some other examples: PRIo8, PRIuMAX, SCNoFAST16.

Edit: BTW a related question asked why that method was used. You may find the answers interesting.

Improve this answer
Sign up to request clarification or add additional context in comments.

4 Comments

It should be SCNu32 for uint32_t. SCNi32 is for int32_t.
-1: They are not declared there, except as a non-standard extension.
@phresnel, a question about int8_t obviously assume either C++0X or an extension importing those from C99 before the standard does so. In the first case, <inttypes.h> is present, in the second one, assuming the import of <inttypes.h> at the same time as <stdint.h> is a pretty safe bet for the implementation I know.
As this is a popular Q & A, suggest a comment about a tangential issue: the certainly problematic trailing '\n' in a scanf() format.
7

As others said, include <stdint.h> header that defines the format macros. In C++, however, define __STDC_FORMAT_MACROS prior to including it. From stdint.h:

/* The ISO C99 standard specifies that these macros must only be defined if explicitly requested. */ #if !defined __cplusplus || defined __STDC_FORMAT_MACROS
Improve this answer

1 Comment

And according to C++0X, "The macros defined by <cinttypes> are provided unconditionally. In particular, the symbol __STDC_FORMAT_MACROS, mentioned in footnote 182 of the C standard, plays no role in C++." But defining __STDC_FORMAT_MACROS may helps with extensions not updated to follow C++0X.
2

According to 7.19.6 Formatted input/output functions of ISO/IEC 9899:TC2, there are no such format specifiers (so I doubt there any for C++2003). Even though there are some #define-macros available in C99's inttypes.h, cinttypes and inttypes.h are not part of the current standard. Of course, fixed-size integer types are non-standard as well.

Anyways, I seriously recommemend using streams instead:

<any_type> x; f >> x;

and be done. E.g.:

std::stringstream ss; uint32_t u; std::cin >> u;

This has the advantage that one time in the future, changing the type of the variable does not cause a cascade of subtle bugs and undefined behaviour.

Improve this answer

5 Comments

Using ">>" appears much slower than fscanf, 2-3 times on VC++ 2010
@sergtk: That's a feature. By default, iostreams are synced with C functions. You can disable this and the result will be that iostreams are as least as fast.
I suppose you mean std::ifstream.sync_with_stdio(false); . This does not improve speed reasonably. Moreover if string is read by << operator, then parsed with sscanf, then speed is almost the same as with fscanf. This means that parsing values is slower with iostream and this is not connected with sync.
@sergtk: Hmm, not in my benchmarks: stackoverflow.com/a/9747716/76722 and stackoverflow.com/a/9212163/76722. And I am not sure why you want to use <<, then sscanf as an alternative to fscanf.
First link contains testing when chars are read, this does not involves converting types. Second link is more interesting since it already contains int-s. But we used different compilers. I tested mostly with int-s and float-s. Even more interesting that in fact all file reading in my testing is still with std::ifstream. But initially it was used to read any types with "<<". But optimised version reads strings with getline(ifstream&, string&), then parsed with sscanfs for strings. Performance improved just because using other conversion of types, not by optimising reading data.
0

In C, the header is <inttypes.h>, and formats such as SCNX8, SCNd16.

The same header probably works for C++ too.

Improve this answer

1 Comment

<inttypes.h> has been imported in the C++ standard at the same time as <stdint.h> (which declares the typedef int8_t and friends), formally in C++0X but in practice available as extension in implementations having a strong relationship with an implementation of C99.
0

The right format to read a uint64_t (typedef unsigned long long int) is, with scanf and not sscanf, "%" SCNu64 and for print is also SCNu64 Example. in your code you read for example my_integer variable, then you do scanf ("Value of integer:%" SCNu64, & my_integer); and to write the same but with printf.

Improve this answer

Comments

0

You can check types in <cstdint> for C++ or in <types.h> for C. Then you can specify format which is currently compiled on your machine. If variable is unsigned then you need to use %u, if variable is signed, then use %d. For variables size lower than 32 bytes you don't have to specify long prefix.

In my configuration I have 64 bit program, so my uint64_t is compiled as unsigned long long int, so it means to use %llu. If your program will be compiled in 32 bit you can use %lu because uint64_t will be compiled as unsigned long int

But who is using x86 still? :), so generally:

uint8_t, uint16_t, uint32_t - %u uint64_t - %llu int8_t, int16_t, int32_t - %d int64_t -%lld
Improve this answer

1 Comment

Please add some explanation to your answer such that others can learn from it
-2

Refer to this for sscanf usage.

These datatypes are defined in stdint.h. Refer here for stdint.h

Shash

Improve this answer

3 Comments

Refering is not answering. It primarily tells you don't know yourself.
I dont believe in copy, paste if it is available over net!! + This is like joining the dots, sscanf & stdint, dont you think ?
But stackoverflow answers should stay valid in itself. At least tell where at cplusplus.com/reference/clibrary/cstdio/sscanf it is mentioned how to format int64 et al.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.