(See alsotype for type system overview andthe list of type-related utilities that are provided by the C++ library)

The following types are collectively calledfundamental types :

• (possibly cv-qualified)void

• integral types
• floating-point types

[edit]void

void — type with an empty set of values. It is anincomplete type that cannot be completed (consequently, objects of typevoid are disallowed). There are noarrays ofvoid, norreferences tovoid. However,pointers tovoid andfunctions returning typevoid (procedures in other languages) are permitted.

[edit]Integral types

[edit]Standard integer types

int — basic integer type. The keywordint may be omitted if any of the modifiers listed below are used. If no length modifiers are present, it's guaranteed to have a width of at least 16 bits. However, on 32/64 bit systems it is almost exclusively guaranteed to have width of at least 32 bits (see below).

[edit]Modifiers

Modifies the basic integer type. Can be mixed in any order. Only one of each group can be present in type name.

• Signedness:

signed — target type will have signed representation (this is the default if omitted)

unsigned — target type will have unsigned representation

• Size:

short — target type will be optimized for space and will have width of at least 16 bits.

long — target type will have width of at least 32 bits.

Note: as with all type specifiers, any order is permitted:unsignedlonglongint andlongintunsignedlong name the same type.

[edit]Properties

The following table summarizes all available standard integer types and their properties in various common data models:

Note: integer arithmetic is defined differently for the signed and unsigned integer types. Seearithmetic operators, in particularinteger overflows.

std::size_t is the unsigned integer type of the result of thesizeof operator as well as thesizeof... operator and thealignof operator(since C++11).

[edit]Boolean type

bool — integer type, capable of holding one of the two values:true orfalse. The value ofsizeof(bool) is implementation defined and might differ from1.

[edit]Character types

Character types are integer types used for a character representation.

signedchar — type for signed character representation.

unsignedchar — type for unsigned character representation. Also used to inspectobject representations (raw memory).

char — type for character representation which can be most efficiently processed on the target system (has the same representation and alignment as eithersignedchar orunsignedchar, but is always a distinct type).Multibyte characters strings use this type to represent code units.For every value of typeunsignedchar in range[​0​, 255], converting the value tochar and then back tounsignedchar produces the original value.(since C++11) The signedness ofchar depends on the compiler and the target platform: the defaults for ARM and PowerPC are typically unsigned, the defaults for x86 and x64 are typically signed.

wchar_t — type for wide character representation (seewide strings). It has the same size, signedness, and alignment as one of the integer types, but is a distinct type. In practice, it is 32 bits and holds UTF-32 on Linux and many other non-Windows systems, but 16 bits and holds UTF-16 code units on Windows. The standard used to requirewchar_t to be large enough to represent any supported character code point. However, such requirement cannot be fulfilled on Windows, and thus it is considered as adefect and removed.

Besides the minimal bit counts, the C++ Standard guarantees that

1==sizeof(char)≤sizeof(short)≤sizeof(int)≤sizeof(long)≤sizeof(longlong).

Note: this allows the extreme case in whichbytes are sized 64 bits, all types (includingchar) are 64 bits wide, andsizeof returns1 for every type.

[edit]Floating-point types

[edit]Standard floating-point types

The following three types and their cv-qualified versions are collectively called standard floating-point types.

float — single precision floating-point type. UsuallyIEEE-754 binary32 format.

double — double precision floating-point type. UsuallyIEEE-754 binary64 format.

longdouble — extended precision floating-point type. Does not necessarily map to types mandated by IEEE-754.

• IEEE-754 binary128 format is used by some HP-UX, SPARC, MIPS, ARM64, and z/OS implementations.
• The most well knownIEEE-754 binary64-extended format isx87 80-bit extended precision format. It is used by many x86 and x86-64 implementations (a notable exception is MSVC, which implementslongdouble in the same format asdouble, i.e. binary64).
• On PowerPCdouble-double can be used.

[edit]Properties

Floating-point types may supportspecial values:

• infinity (positive and negative), seeINFINITY
• thenegative zero,-0.0. It compares equal to the positive zero, but is meaningful in some arithmetic operations, e.g.1.0/0.0==INFINITY, but1.0/-0.0==-INFINITY), and for some mathematical functions, e.g.sqrt(std::complex)
• not-a-number (NaN), which does not compare equal with anything (including itself). Multiple bit patterns represent NaNs, seestd::nan,NAN. Note that C++ takes no special notice of signalling NaNs other than detecting their support bystd::numeric_limits::has_signaling_NaN, and treats all NaNs as quiet.

Floating-point numbers may be used witharithmetic operators+,-,/, and* as well as various mathematical functions from<cmath>. Both built-in operators and library functions may raise floating-point exceptions and seterrno as described inmath errhandling.

Floating-point expressions may have greater range and precision than indicated by their types, seeFLT_EVAL_METHOD. Floating-point expressions may also becontracted, that is, calculated as if all intermediate values have infinite range and precision, see#pragma STDC FP_CONTRACT. Standard C++ does not restrict the accuracy of floating-point operations.

Some operations on floating-point numbers are affected by and modify the state ofthe floating-point environment (most notably, the rounding direction).

Implicit conversions are defined between floating types and integer types.

Seelimits of floating-point types andstd::numeric_limits for additional details, limits, and properties of the floating-point types.

[edit]Range of values

The following table provides a reference for the limits of common numeric representations.

Prior to C++20, the C++ Standard allowed any signed integer representation, and the minimum guaranteed range of N-bit signed integers was from\(\scriptsize -(2^{N-1}-1)\)-(2N-1
-1) to\(\scriptsize +2^{N-1}-1\)+2N-1
-1 (e.g.−127 to127 for a signed 8-bit type), which corresponds to the limits ofones' complement orsign-and-magnitude.

However, all C++ compilers usetwo's complement representation, and as of C++20, it is the only representation allowed by the standard, with the guaranteed range from\(\scriptsize -2^{N-1}\)-2N-1
to\(\scriptsize +2^{N-1}-1\)+2N-1
-1 (e.g.−128 to127 for a signed 8-bit type).

8-bit ones' complement and sign-and-magnitude representations forchar have been disallowed since C++11 (via the resolution ofCWG issue 1759), because a UTF-8 code unit of value 0x80 used in aUTF-8 string literal must be storable in achar type object.

The range for a floating-point typeT is defined as follows:

• The minimum guaranteed range is the most negative finite floating-point number representable inT through the most positive finite floating-point number representable inT.
• If negative infinity is representable inT, the range ofT is extended to all negative real numbers.
• If positive infinity is representable inT, the range ofT is extended to all positive real numbers.

Since negative and positive infinity are representable inISO/IEC/IEEE 60559 formats, all real numbers lie within the range of representable values of a floating-point type adhering to ISO/IEC/IEEE 60559.

1. ↑The object representation usually occupies 96/128 bits on 32/64-bit platforms respectively.

Note: actual (as opposed to guaranteed minimal) limits on the values representable by these types are available inC numeric limits interface andstd::numeric_limits.

[edit]Data models

The choices made by each implementation about the sizes of the fundamental types are collectively known asdata model. Four data models found wide acceptance:

32 bit systems:

• LP32 or2/4/4 (int is 16-bit,long and pointer are 32-bit)

• Win16 API

• ILP32 or4/4/4 (int,long, and pointer are 32-bit);

• Win32 API
• Unix and Unix-like systems (Linux, macOS)

64 bit systems:

• LLP64 or4/4/8 (int andlong are 32-bit, pointer is 64-bit)

• Win32 API (also called the Windows API) with compilation target64-bit ARM (AArch64) orx86-64 (a.k.a. x64)

• LP64 or4/8/8 (int is 32-bit,long and pointer are 64-bit)

• Unix and Unix-like systems (Linux, macOS)

Other models are very rare. For example,ILP64 (8/8/8:int,long, and pointer are 64-bit) only appeared in some early 64-bit Unix systems (e.g.UNICOS on Cray).

[edit]Notes

[edit]Keywords

void,bool,true,false,char,char8_t,char16_t,char32_t,wchar_t,int,short,long,signed,unsigned,float,double

[edit]Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit]References

[edit]See also

• The C++ type system overview
• Const-volatility (cv) specifiers and qualifiers
• Storage duration specifiers

• In other languages

• العربية
• Deutsch
• Español
• Français
• Italiano
• 日本語
• Polski
• Português
• Русский
• 中文