I'm seeking for specific information on the sizes of basic C++ types. I understand that it is determined by the architecture (16 bits, 32 bits, or 64 bits) and the compiler.
But are there any C++ standards?
On a 32-bit architecture, I'm using Visual Studio 2008. This is what I get:
I looked for solid information on the sizes of char, short, int, long, double, float (and additional kinds I didn't think of) under different architectures and compilers, but had little luck and only got this [link moderated].

The article you cited answers your question perfectly.

Sizeof on the system you are using.

The C and C++ standards don't define type sizes. Type sizes are compiler/architecture/OS/Data-model dependent. Take a look at this C data types and 64-bit_data_models

Now, for Visual C++, Microsoft has fixed sizes, probably to maximize compatibility between Windows versions. See Sizes of built-in types:

Most built-in types have implementation-defined sizes. The following table lists the amount of storage required for built-in types in Microsoft C++. In particular, long is 4 bytes even on 64-bit operating systems.

As mentioned before, just check the size of the type you are interested with:

Sorry, I forgot to say, if you want an integer of an specific size you have to include the <stdint.h> header, there there are definitions for:
For float point values, almost all architectures/compilers use IEEE 754 standard

1 members found this post helpful.

And to complete @wainamoinen's thought, you should use these definitions if you actually care about the "size of" an integer and want your code to be portable. (This also makes your intentions clear to the human reader ...)

In the case of struct, you also need to be aware of the possibility of padding. Unless you specify that the struct is to be "packed" into the minimal amount of space – and I don't believe that there is a standard way to do this (unlike Pascal) – the compiler might insert extra bytes in order to align the various struct members most advantageously for the hardware in question. (For example, highly-pipelined 64-bit architectures "like" for things to sit on 64-bit address boundaries because the pipeline works better that way.) Unless you specify that it mustn't do this, the compiler presumes that it is free to do so.

Note: In Windows, both of types WPARAM and LPARAM are 32/64 bit long (32 bit on x86, 64 bit on amd64), the first is unsigned, the latter is signed.

The first three entries here should cover it:

https://c-faq.com/decl/index.html

Optimizing the sizes of integer variables does not have much benefit on modern hardware.

I recommend using "long" by default (rather than "int") to preclude the possibility of overflow on 64-bit machines. In practice, "long" will never overflow on 64-bit machines.

The shorter types are useful only in specific circumstances:

* 32-bit int for pixel coordinates, RGBA values, and Unicode characters
* 16-bit short for audio data
* 8-bit char for strings

Ed

And floats for GPUs

Yes. Everything else should use "double".
Ed

Probably the only situation where this would actually become important is when you need to match some externally-defined struct ... and you somehow don't have access to a public source-library that already does it for you, which is unlikely.

Vendor-defined type definitions such as "WPARAM" or "LPARAM" should always be followed when available, because their libraries make use of the same definitions, and they control those definitions. Above all, in your source code you should make your intentions crystal clear to the human reader: "say what you mean." (And if possible ... and this depends on the language you are using ... "have the compiler be able to catch your stpiud misteaks.") "Strong type-checking is a virtue."