14

With printf(), I can use %hhu for unsigned char, %hi for a short int, %zu for a size_t, %tx for a ptrdiff_t, etc.

What conversion format specifier do I use for a _Bool? Does one exist in the standard?

Or do I have to cast it like this:

_Bool foo = 1;
printf("foo: %i\n", (int)foo);
Peter Mortensen
  • 30,738
  • 21
  • 105
  • 131
Richard Hansen
  • 51,690
  • 20
  • 90
  • 97
  • 1
    I don't think you need a cast in front of `foo`: `_Bool` will be cast to `int` by default. – Sergey Kalinichenko Jun 28 '12 at 18:07
  • You don't need. `_Bool` is typedef to `int` in C99. – Jack Jun 28 '12 at 18:19
  • Plus, even if `_Bool` wasn't a typedef for `int`, `printf()` isn't type-safe; if you push a value the same size as an `int` onto the stack, and tell `printf()` to print it as an `int`, by golly `printf()` will print it as an `int`, no questions asked. – steveha Jun 28 '12 at 18:25
  • @dasblinkenlight: I'm not sure that's true: C99 6.5.2.2p7 says "The ellipsis notation in a function prototype declarator causes argument type conversion to stop after the last declared parameter." – Richard Hansen Jun 28 '12 at 18:28
  • 2
    @RichardHansen If I recall it correctly, default promotions always apply to varargs: floats become doubles, chars become ints, and so on. This may have changed in C99, I am not sure. – Sergey Kalinichenko Jun 28 '12 at 18:36
  • 1
    @Jack: I'm skeptical -- citation needed. :) C99 6.3.1.1p1 says that the conversion rank of `_Bool` is less than the rank of all other standard integer types, which can't be true if it's `typedef`ed (right?). Also, 6.3.1.2 describes special conversion rules for `_Bool`, which won't work if `_Bool` is simply `typedef`ed to `int`. – Richard Hansen Jun 28 '12 at 18:37
  • 3
    @Jack No, it most certainly is not; please don't post false information. The default promotions apply when the type of the parameter isn't declared, so _Bool is implicitly converted to int. – Jim Balter Jun 28 '12 at 19:06
  • 2
    @Jack: `_Bool` is definitely *not* a typedef for `int`. `_Bool` is a keyword, and it's a distinct type. – Keith Thompson Jun 28 '12 at 19:07
  • @dasblinkenlight: You are right -- the very next sentence in C99 6.5.2.2p7 says "The default argument promotions are performed on trailing arguments." It took me some squinting and pondering to understand that the "trailing arguments" are the ones that go with the ellipsis. – Richard Hansen Jun 28 '12 at 20:13
  • Related: *[What is the printf format specifier for bool?](https://stackoverflow.com/questions/17307275/what-is-the-printf-format-specifier-for-bool)*. See also [the linked questions](https://stackoverflow.com/questions/linked/17307275?sort=votes). – Peter Mortensen Aug 07 '23 at 20:17

5 Answers5

13

There is no specific conversion length modifier for _Bool type.

_Bool is an unsigned integer type large enough to store the values 0 and 1. You can print a _Bool this way: 

_Bool b = 1;
printf("%d\n", b);

Because of the integer promotions rules, _Bool is guaranteed to promote to int.

ouah
  • 142,963
  • 15
  • 272
  • 331
  • %u works as well, especially for those retentive types like myself who prefer to always use unsigned specifiers with unsigned types. Also, I think `_Bool b = true;` is better usage. – Jim Balter Jun 28 '12 at 19:33
  • 1
    This is currently the most correct answer -- `_Bool` will be promoted to an `int`, not an `unsigned int`. For posterity, it'd be nice if the answer contained references to the C99 standard specifying this behavior. – Richard Hansen Jun 28 '12 at 20:27
  • 1
    6.5.2.2p7 for default argument promotions for arguments corresponding to the ellipsis, 6.5.2.2p6 for the definition of default argument promotion, 6.3.1.1 for integer promotions – Richard Hansen Jun 28 '12 at 20:27
6

Until C99, bool was not apart of standard C, and thus did not exist as a printf modifier. C99, defined _Bool (which you are using) to be an integer, thus you should be fine casting it as an integer to display (at least from a machine perspective). Alternatively, you could do something like:

printf("%d",foo?1:0);
Clarus
  • 2,259
  • 16
  • 27
  • 4
    or if you want to print a string as output you could do: `printf("foo: %s\n", foo ? "true" : "false");` – Jite Jun 28 '12 at 18:12
  • Sure, that alternative also works and is probably easier to type. However, I'm less interested in the various ways to print `_Bool` than confirmation that there is no length modifier or conversion specifier for `_Bool`. (A bonus would be a link to discussion as to why it doesn't exist: Oversight? Deemed unnecessary?) – Richard Hansen Jun 28 '12 at 18:43
  • The responses in the comments above are correct: there is no need to cast it, because it is automatically promoted ... and so there is no need for the ?: either. And the fact that there wasn't a printf modifier before C99 is irrelevant; they could have added one when they added _Bool ... but if they had, it would have printed "true" or "false". – Jim Balter Jun 28 '12 at 19:13
  • @RichardHansen You can determine what printf formats there are and a lot more by obtaining and reading the standard yourself online, as there are free working drafts before and after the official standard ... just google C99 standard. – Jim Balter Jun 28 '12 at 19:21
  • @RichardHansen You can also obtain the C99 Rationale online. However, there is no mention there of a printf format for _Bool (to be expected, as mostly it explains why things were done, rather than why they weren't). – Jim Balter Jun 28 '12 at 19:29
2

As you stated in a comment to @Jack, "6.3.1.1p1 says that the conversion rank of _Bool is less than the rank of all other standard integer types".

In a call to printf, a char or short will be promoted and passed on the stack as an int (or an unsigned int), so I would think that using %d as a format specifier would be fine. That also means that you don't need the explicit cast to int, because that will happen automatically.

The only possible issue would be with how the compiler represents a _Bool, something that it probably implementation defined and could vary from one compiler to another. I see two likely implementations -- 0 and 1 or 0 and -1.

For the ultimate in portability, follow @user325181's answer and use a ternary to choose between two options. Either integers (which the compiler may optimize away) or strings.

Edit: As reported in other answers, a _Bool is defined as an unsigned integral type that can store either 0 or 1. Because of that, and the fact that it will be promoted to an unsignedint when passed to printf(), I would say that %u%d is the most appropriate specifier.

tomlogic
  • 11,489
  • 3
  • 33
  • 59
  • 2
    It's impossible to store into `_Bool` any value other than `0` or `1` (6.3.1.2). So the conversion back to `int` will (barring undefined behaviour) always yield `0` or `1`. – ecatmur Jun 28 '12 at 19:06
  • @ecatmur: Yes, and the macros `false` and `true` in `` expand to `0` and `1`, respectively. – Keith Thompson Jun 28 '12 at 19:09
  • C says `_Bool` is an unsigned integer type so `-1` is not possible. – ouah Jun 28 '12 at 19:11
  • 1
    C99 6.3.1.1p2 says "If an `int` can represent all values of the original type, the value is converted to an `int`; otherwise, it is converted to an `unsigned int`." Since an `int` can represent all values of a `_Bool`, it will be promoted to an `int`, not an `unsigned int` (even though `_Bool` is an unsigned integer type). – Richard Hansen Jun 28 '12 at 20:18
1

There is no. Just handling it like an int by using %d or %i specifier.

_Bool

In C99, a new keyword, _Bool, is introduced as the new boolean type. In many aspects, it behaves much like an unsigned int, but conversions from other integer types or pointers always constrained to 0 and 1. Other than for other unsigned types, and as one would expect for a boolean type, such a conversion is 0 if and only if the expression in question evaluates to 0 and it is 1 in all other cases. The header stdbool.h provides macros bool, true and false that are defined as _Bool, 1 and 0, respectively.

The first way to implement it that come from into mind is by using a char or(int8_t) an enum and with bit fields. But actually, it depends. It can be a typedef for an int(as I've mentioned, it's used, but is not recommend, subject to bugs) or char or unsigned int or an enum and #define that's commonly used.

For exampe, Apple's implementation uses int,as you can see:

#ifndef _STDBOOL_H_
#define _STDBOOL_H_ 

#define __bool_true_false_are_defined   1

#ifndef __cplusplus

#define false   0
#define true    1

#define bool    _Bool
#if __STDC_VERSION__ < 199901L && __GNUC__ < 3
typedef int _Bool;
#endif

#endif /* !__cplusplus */

#endif /* !_STDBOOL_H_ */

Others implementations:

typedef int8_t _Bool;

typedef enum { false = 0, true = 1 } bool;

typedef unsigned char Boolean; typedef _Bool Boolean;

Community
  • 1
  • 1
Jack
  • 16,276
  • 55
  • 159
  • 284
  • 1
    And none of those implementations are C99. `_Bool` is a keyword in C99, and you won't find it defined in any headers. In the Apple example above, it's defining it for versions of C before C99. In your other examples, you have a `bool` type, and a `Boolean` type that is defined as an `unsigned char` or `_Bool`. – tomlogic Jun 28 '12 at 20:09
0

I use %b for a Java printf() conversion specifier. I tried it recently and to my surprise it worked.

Here is the line of code:

System.out.printf("firstRobot == secondRobot: %b",firstRobot == secondRobot);

Here is the output:

firstRobot == secondRobot: false
Yu Hao
  • 119,891
  • 44
  • 235
  • 294
Stephanie G
  • 1
  • 1