Advantages/Disadvantages of using __int16 (or int16_t) over int

Saving 2 bytes is almost never worth it. However, saving thousands of bytes is. If you have an large array containing integers, using a small integer type can save quite a lot of memory. This leads to faster code, because the less memory one uses the less cache misses one receives (cache misses are a major loss of performance).

TL;DR: this is beneficial to do in large arrays, but pointless for 1-off variables.

The second use of these is if for dealing with binary files and messages. If you are reading a binary file that uses 16-bit integers, well, it's pretty convenient if you can represent that type exactly in your code.

BTW, don't use microsoft's versions. Use the standard versions (std::int16_t)

If you for some reason just need a shorter integer type it's already have that in the language - called short - unless you know you need exactly 16 bits there's really no good reason not to just stick with the agnostic short and int types. The broad idea is that these types should align well the target architecture (for example see word ).

That being said, theres no need to use the platform specific type (__int16), you can just use the standard one:

int16_t

See https://en.cppreference.com/w/cpp/types/integer for more information and standard types

Even if you still insist on __int16 you probably want a typedef something ala.:

using my_short = __int16;

Update

Your main question is:

What is the advantage/disadvantage of saving 2 bytes by using 16-bit version of an integer instead of int ?

If you have a lot of data (In the ballpark of at least some 100.000-1.000.000 elements as a rule of thumb) - then there could be an overall performance saving in terms of using less cpu-cache. Overall there's no disadvantage of using a smaller type - except for the obvious one - and possible conversions as explained in this answer

It depends.

On x86, primitive types are generally aligned on their size. So 2-byte types would be aligned on a 2-byte boundary. This is useful when you have more than one of these short variables, because you will be saving 50% of space. That directly translates to better memory and cache utilization and thus theoretically, better performance.

On the other hand, doing arithmetic on shorter-than-int types usually involves widening conversion to int. So if you do a lot of arithmetic on these types, using int types might result in better performance (contrived example).

So if you care about performance of a critical section of code, profile it to find out for sure if using a certain data type is faster or slower.

A possible rule of thumb would be - if you're memory-bound (i.e. you have lots of variables and especially arrays), use as short a data types as possible. If not - don't worry about it and use int types.

The main reason for using these types is to make sure about the size of your variable in different architectures and compilers. we call it "code reusability" and "portability"

in higher-level modern languages, all this will handle with compiler/interpreter/virtual machine/etc. that you don't need to worry about, but it has some performance and memory usage costs.

When you have some kind of limitation you may need to optimize everything. The best example is embedded systems that have a very limited size of memory and work at low frequency. In the other hand, there are lots of compilers out there with different implementations. Some of them interpret "int" as a "16bit" value and some as a "32bit".

for example, you receive and specific stream of values over a communication system, you want to save them in a buffer or array and you want to make sure the input data is always interpreted as a 16bit noting else.