2

Firstly,I tried sizeof(signed short), the output was 2 bytes.

BUT When I tried to check by the hex representation of the signed short, it turns out to be 4 bytes :

#include <stdio.h>
 void main(){
 signed short  test  ;
 test=-17; /* any number */
 printf(" -17 when viewed as signed short Hexa is \t %x\n ", test);
 }`

The output : 

-17 when viewed as signed short Hexa is      ffffffef

ffffffef means 32 bits not 16 bits !

Mohamed Sayed
  • 93
  • 1
  • 3
  • 10
  • 4
    It's promoted to `int`, `printf()` is not a good way to check that use the `sizeof()` operator. It will give you exactly what you want i.e. the number of bytes. – Iharob Al Asimi Jan 24 '16 at 19:10
  • 1
    Actually, not to be pedantic, but I think `printf` promotes `%x` to `unsigned int`. – conradkleinespel Jan 24 '16 at 19:33
  • I think, it is actually undefined behaviour. In the call to printf, the arguments are pushed on the stack "as is", i.e. disregarding if the type matches the format specifier. If there is now a mismatch between the value type expected and the actual value type, it is undefined what is happening. At least, if printf isn't handled specially by the compiler compared to other varargs function calls. – Ctx Jan 24 '16 at 19:42
  • 1
    @conradk pedantic detail: The compiler promotes sub-`int/unsigned` _actual arguments_ to `int/unsigned`. This is done before `printf()` receives the parameters. `printf("%x", ...)` expects an `unsigned` and will accept an `int`. – chux - Reinstate Monica Jan 24 '16 at 20:54
  • @chux: Having recoded `printf` myself for learning purposes, I don't get it. What's your source? Genuinely interested to understand. – conradkleinespel Jan 24 '16 at 20:58
  • @conradk Source C11 spec. [rici](http://stackoverflow.com/a/34981236/2410359) provides good insight. Advise if that is insufficient. – chux - Reinstate Monica Jan 24 '16 at 21:02
  • @conradk read up on C argument passing. All sub-int are promoted to int, all sub-double promoted to double. – vonbrand Jan 26 '16 at 18:40
  • At least 2. But e.g on a Cray all of char/short/int/long are 32 bits. – vonbrand Jan 26 '16 at 18:56
  • Possible duplicate of [printf adds extra \`FFFFFF\` to hex print from a char array](https://stackoverflow.com/questions/31090616/printf-adds-extra-ffffff-to-hex-print-from-a-char-array) – phuclv Dec 22 '17 at 04:14

3 Answers3

2

The specifier %x requires an integer, and the compiler automatically converts your short to int before to print it.
If your type is a signed type the compiler performs also sign extension, this means that if the value is negative it will propagate to the upper word of int. I.e. if we have -17=0xffef for a short converting it to int we will have oxffffffef. If we had a positive value like 17=0x11, will be 0x11 for an int too and will print out as 0x11.
So the test you made makes no sense.
On the other hand the size of a type (int, short, etc) is compiler and/or machine dependent, and using the sizeof() operator is the correct way to check its size.

Frankie_C
  • 4,764
  • 1
  • 13
  • 30
  • is any `short` automatically converted or promoted to `int` as long as the specifier is `%` ?... I changed `signed short` to `unsigned short` and the specifier was still `%`, but the output was `ffef` i.e. **16 bits** which means no convertion...i know that i assigned -ve value to `unsigned short' but i think it doesn't have an effect on the size of the datatype . – Mohamed Sayed Jan 24 '16 at 20:06
  • There is also another error in your previous comment, changing to `unsigned short` and assigning a negative value, that should also generate a warning, loads the variable with the negative value representation in 16bits, but when converting to int it is taken as `unsigned` value `short int -17 = 0xffef = 65519`, so no **sign extension** is performed. – Frankie_C Jan 24 '16 at 20:28
2

printf is a varargs function; it's prototype is:

int printf(const char *format, ...);

That means that the first argument has type const char*, and the remaining arguments do not have a specified type.

Arguments without a specified type undergo the default argument promotions:

  1. float arguments are converted to double.

  2. integer types (both signed and unsigned) which are strictly narrower than an int are converted to a signed int.

  3. all other arguments are unchanged.

This happens before printf is called, and is not in any way specific to printf. The arguments in a call to any varargs function (which has an ... in its prototype).

Varargs functions have no way of knowing the types of their arguments, so they need to have some convention which lets the caller tell the function what types to expect. In the case of printf, the types are specified in the format string, and printf uses the specified type in the format string in the expectation that it is correct. If you lie to printf by telling it that an argument is of a certain type when it is actually of a different type, the resulting behaviour is undefined, and is occasionally catastrophic (although usually it just means that the wrong thing is printed.)

Printf is aware of the default argument promotions. So if you tell it to expect an unsigned short, for example, then it will actually expect either an int (if int is wider than unsigned short) or unsigned int if int and short are the same size.

The type of a format item is specified using the format code (such as d and x, which are signed and unsigned int respectively) and possibly modifiers. In particular, the modifier h changes the expectation from int to short, while hh changes it to char. (It doesn't affect the signedness.)

So, if you provide a signed short, then you should use the format code %hd. If you provide an unsigned short, you should use %hu or %hx, depending on whether you want the output in decimal or hexadecimal. There is no way to specify a hexadecimal conversion of a signed argument, so you need to cast the argument to an unsigned type in order to use the hexadecimal format code:

printf("This signed short is printed as unsigned: %hx\n",
       (unsigned short)x);

That will first convert x from short to unsigned short; then (because of the default argument promotions, and assuming short is actually shorter than int) to int. That int is what is actually sent to printf. When printf sees the %hx format code, it knows that it should expect the default promotion of an unsigned short (that is, an int); it takes that int and converts it back to an unsigned short, which it then prints.

Many programmers would just write %x without a cast, just as you did. Technically, that is undefined behaviour and the rather wordier expression above is correct but pedantic. However, it is worth noting that it produces the expected value, whereas the incorrect %x format code without the cast does not.

rici
  • 234,347
  • 28
  • 237
  • 341
  • Nice answer: detail: "Assuming short is actually shorter than int,..." ---> assumption not needed. All `short` are converted to `int`. "If an int can represent all values of the original type (as restricted by the width, for a bit-field), the value is converted to an `int`; otherwise, it is converted to an `unsigned int`." – chux - Reinstate Monica Jan 24 '16 at 21:11
  • @chux: if short and int are the same size, the argument will be an unsigned int rather than an int. The effect is the same, of course. Perhaps there is a better wording which doesn't get lost in a sea of details. – rici Jan 24 '16 at 21:36
  • If `short` and `int` are the same size, The `short` becomes an `int`. Still this is the best answer. – chux - Reinstate Monica Jan 25 '16 at 05:06
  • @chux: but i'm explicitly casting the short to an unsigned short, because I'm going to use an unsigned format code. That will be default promoted to int anyway if short is narrower, or to unsigned int if they are the same width. Then printf needs to retrieve an unsigned short from whichever of those two it got. That will work in either case, but I was trying to avoid encumbering the explanation while remaining pedantically correct. Anyway, thanks for the vote. – rici Jan 25 '16 at 05:23
  • @chux: moved the phrase in case that makes its raison d'etre more apparent. – rici Jan 25 '16 at 05:27
1

Wikipedia has some nice tables that show the different min/max sizes of different types of integers, including short int:

Short signed integer type. Capable of containing at least the [−32767, +32767] range; thus, it is at least 16 bits in size.

This means that you should consider short int to be no larger than 16 bits if you want your code to be cross platform and cross compiler. But you should still use sizeof(short int) if you need the actual size (for calculating data length at runtime) because a short int might be 32 bits on some platforms.

conradkleinespel
  • 6,560
  • 10
  • 51
  • 87