There are five *standard signed integer types*:
“signed char”, “short int”, “int”,
“long int”, and “long long int”.

In
this list, each type provides at least as much storage as those
preceding it in the list.

The standard and extended signed integer types are collectively called
*signed integer types*.

The range of representable values for a signed integer type is
to (inclusive),
where *N* is called the *width* of the type.

For each of the standard signed integer types,
there exists a corresponding (but different)
*standard unsigned integer type*:
“unsigned char”, “unsigned short int”,
“unsigned int”, “unsigned long int”, and
“unsigned long long int”.

Likewise, for each of the extended signed integer types,
there exists a corresponding *extended unsigned integer type*.

The standard and extended unsigned integer types
are collectively called *unsigned integer types*.

An unsigned integer type has the same width *N*
as the corresponding signed integer type.

The range of representable values for the unsigned type is
0 to (inclusive);
arithmetic for the unsigned type is performed modulo .

[*Note 2*: *end note*]

Unsigned arithmetic does not overflow.

Overflow for signed arithmetic yields undefined behavior ([expr.pre]).

— An unsigned integer type has the same
object representation,
value representation, and
alignment requirements ([basic.align])
as the corresponding signed integer type.

The value representation of a signed or unsigned integer type
comprises N bits, where N is the respective width.

Each set of values for any padding bits ([basic.types])
in the object representation are
alternative representations of the value specified by the value representation.

Except as specified above,
the width of a signed or unsigned integer type is
implementation-defined.

Each value x of an unsigned integer type with width N has
a unique representation ,
where each coefficient is either 0 or 1;
this is called the *base-2 representation* of x.

The base-2 representation of a value of signed integer type is
the base-2 representation of the congruent value
of the corresponding unsigned integer type.

The standard signed integer types and standard unsigned integer types
are collectively called the *standard integer types*, and the extended
signed integer types and extended
unsigned integer types are collectively called the
*extended integer types*.

A fundamental type specified to have
a signed or unsigned integer type as its *underlying type* has
the same object representation,
value representation,
alignment requirements ([basic.align]), and
range of representable values as the underlying type.

Further, each value has the same representation in both types.

Type char is a distinct type
that has an implementation-defined choice of
“signed char” or “unsigned char” as its underlying type.

The values of type char can represent distinct codes
for all members of the implementation's basic character set.

The three types char, signed char, and unsigned char
are collectively called
*ordinary character types*.

For narrow character types,
each possible bit pattern of the object representation represents
a distinct value.

[*Note 6*: *end note*]

A bit-field of narrow character type whose width is larger than
the width of that type has padding bits; see [basic.types].

— Type bool is a distinct type that has
the same object representation,
value representation, and
alignment requirements as
an implementation-defined unsigned integer type.

Types
bool,
char, wchar_t,
char8_t, char16_t, char32_t,
and the signed and unsigned integer types are
collectively called
*integral types*.

A synonym for integral type is *integer type*.

[*Note 8*: *end note*]

Enumerations ([dcl.enum]) are not integral;
however, unscoped enumerations can be promoted to integral types
as specified in [conv.prom].

— The type double provides at least as much
precision as float, and the type long double provides at
least as much precision as double.

The set of values of the type
float is a subset of the set of values of the type
double; the set of values of the type double is a subset
of the set of values of the type long double.

The value
representation of floating-point types is implementation-defined.

[*Note 9*: *end note*]

This document imposes no requirements on the accuracy of
floating-point operations; see also [support.limits].

— Specializations of the standard library template
std::numeric_limits shall specify the
maximum and minimum values of each arithmetic type for an
implementation.

A type cv void
is an incomplete type that cannot be completed; such a type has
an empty set of values.

It is used as the return
type for functions that do not return a value.

Any expression can be
explicitly converted to type cv void ([expr.type.conv],
[expr.static.cast], [expr.cast]).

An expression of type cv void shall
be used only as an expression statement, as an operand
of a comma expression, as a second or third operand
of ?: ([expr.cond]), as the operand of
typeid, noexcept, or decltype, as
the expression in a return statement for a function
with the return type cv void, or as the operand of an explicit conversion
to type cv void.

Such values participate in the pointer and the
pointer-to-member conversions ([conv.ptr], [conv.mem]).