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 width of each standard signed integer type
shall not be less than the values specified in Table 14.

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.general])
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 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.general].

— Type wchar_t is a distinct type that has
an implementation-defined
signed or unsigned integer type as its underlying type.

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

The character types, bool,
the signed and unsigned integer types,
and cv-qualified versions ([basic.type.qualifier]) thereof,
are collectively termed
*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 types
float, double, and long double,
and cv-qualified versions ([basic.type.qualifier]) thereof,
are collectively termed
*standard floating-point types*.

An implementation may also provide additional types
that represent floating-point values and define them (and cv-qualified versions thereof) to be
*extended floating-point types*.

The standard and extended floating-point types
are collectively termed *floating-point types*.

[*Note 9*: *end note*]

Any additional implementation-specific types representing floating-point values
that are not defined by the implementation to be extended floating-point types
are not considered to be floating-point types, and
this document imposes no requirements on them or
their interactions with floating-point types.

—
Except as specified in [basic.extended.fp],
the object and value representations and accuracy of operations
of floating-point types are implementation-defined.

The minimum range of representable values for a floating-point type is
the most negative finite floating-point number representable
in that type through
the most positive finite floating-point number representable in that type.

In addition, if negative infinity is representable in a type,
the range of that type is extended to all negative real numbers;
likewise, if positive infinity is representable in a type,
the range of that type is extended to all positive real numbers.

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.

An expression of type cv void shall
be used only as

- an expression statement ([stmt.expr]),
- the expression in a return statement ([stmt.return]) for a function with the return type cv void,
- an operand of a comma expression ([expr.comma]),
- the second or third operand of ?: ([expr.cond]),
- the operand of a typeid expression ([expr.typeid]),
- the operand of a noexcept operator ([expr.unary.noexcept]),
- the operand of a decltype specifier ([dcl.type.decltype]), or
- the operand of an explicit conversion to type cv void ([expr.type.conv], [expr.static.cast], [expr.cast]).

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