6

The output of this code:

const char *buff = "*_2D 1";
char field[10];
int flag;
sscanf(buff, "%s %d", field, &flag);
printf("field:%s flag:%i\n", field, flag);

is field:*_2D flag:1

However by changing the int to bool results in strange behaviour:

const char *buff = "*_2D 1";
char field[10];
bool flag;
sscanf(buff, "%s %d", field, &flag);
printf("field:%s flag:%i\n", field, flag);

The output is field: flag:1

Can anyone explain what is happening here? I would've thought the bool would be interpreted as an int, which it appears to be, but the rest of the string disappears.

Salgar
  • 7,687
  • 1
  • 25
  • 39

6 Answers6

11

Imagine if bool is only one byte, rather than the four (or even eight) that an int uses. Then telling sscanf that &flag is a pointer to an int will end up overwriting either three or seven bytes elsewhere on the stack -- which could be right on top of your field variable. That space would be filled with 0 bytes, effectively terminating your string.

Ernest Friedman-Hill
  • 80,601
  • 10
  • 150
  • 186
4

bool is a separate type to int, and is likely to be a single byte (which on most common platforms is smaller than int).

sscanf is not type-safe; you are telling it (with the %d conversion specifier) that you are providing a pointer to an int, and so it assumes that it is safe to write an int there. If the actual type is smaller, then you'll get undefined behaviour; most likely, either other local variables will be overwritten, or the stack frame will be corrupted. In this case, it looks like it is overwriting the beginning of field with the zero-valued bytes of the integer value 1.

Mike Seymour
  • 249,747
  • 28
  • 448
  • 644
3

It could be because sizeof(bool) is sometimes 1 ? So, I don't know much C++, but in C that would be undefined behavior.

cnicutar
  • 178,505
  • 25
  • 365
  • 392
2

According to the spec for sscanf, the description of %d is:

Matches an optionally signed decimal integer... In the absence of a size modifier, the application shall ensure that the corresponding argument is a pointer to int.

Also from the same spec,

if the result of the conversion cannot be represented in the space provided, the behavior is undefined.

Since sizeof(bool) < sizeof(int), you are in the dreaded Undefined Behavior zone, and anything can happen.

SCFrench
  • 8,244
  • 2
  • 31
  • 61
0

The sscanf function failed because bool is not an int but a char

Try this one:

const char *buff = "*_2D 1";
char field[10];
char flag;
sscanf(buff, "%s %d", field, &flag);
printf("field:%s flag:%i\n", field, flag);

It'll give you the same error.

AxFab
  • 1,157
  • 8
  • 11
  • `bool` is not a `char` either; it's a distinct type (assuming this is either C++, or C99 with ``), and not guaranteed to be the same size as `char`. – Mike Seymour Jul 14 '11 at 14:45
  • ...is considere as a 'signed number of one bytes' (like char) for sscanf (in stdbool.h, _Bool is just a typedef) – AxFab Jul 14 '11 at 15:22
  • @Asgar: no: in C99, `bool` is a macro that expands to `_Bool`; `_Bool` is a built-in type, distinct from `char`. In C++, `bool` is a built-in type, again distinct from `char`. The specification of `sscanf` (and `fscanf`, which it references) does not mention `bool` (or `_Bool`) at all. – Mike Seymour Jul 14 '11 at 15:34
0

If you are using C++ (which appears to be the case from your comments), why not use C++ streams instead of the C-style scanf approach ?

const std::string buff = "*_2D 1";
std::string field;
bool flag = false;
std::istringstream ss(buff);
ss >> field >> flag;
std::cout << "field:" << field << " flag:" << flag << std::endl;
Sander De Dycker
  • 16,053
  • 1
  • 35
  • 40