C++ programmers have access to the five data types for C: void, int, float, double, and char.
Type | Description |
---|---|
void | associated with no data type |
int | integer |
float | floating-point number |
double | double precision floating-point number |
char | character |
In addition, C++ defines two more: bool
and wchar_t
.
Type | Description |
---|---|
bool | Boolean value, true or false |
wchar_t | wide character |
Several of these types can be modified using the keywords signed
, unsigned
, short
, and long
. When one of these type modifiers is used by itself, a data type of int
is assumed. A complete list of possible data types follows (equivalent types are displayed in the same row):
integer types | |||
---|---|---|---|
bool |
|||
char |
|||
signed char |
|||
unsigned char |
|||
wchar_t |
|||
short | short int | signed short | signed short int |
unsigned short | unsigned short int |
||
int | signed | signed int |
|
unsigned | unsigned int |
||
long | long int | signed long | signed long int |
unsigned long | unsigned long int |
||
floating point types | |||
float |
|||
double |
|||
long double |
|||
optionally supported integer types | |||
long long | long long int | signed long long | signed long long int |
unsigned long long | unsigned long long in t |
The size and range of any data type is compiler and architecture dependent. You can use the sizeof operator to determine the
size of any data type (frequently expressed as a number of bytes). However, many architectures implement data types of a standard size. ints
and floats
are often 32-bit, chars 8-bit, and
doubles
are usually 64-bit. bools
are often implemented as 8-bit data types.
long long
type is 64-bit. The “cfloat” (or “float.h”) header file defines the ranges for the floating types, the
“climits” (or “limits.h”) - for the integer types.
Limits for numeric values are defined in the <limits> header. The templated values of numeric_limits provide system-dependant numerical representations of the C++ data types. Use the appropriate function given the data type as the template argument as shown in the table below. Note that numeric_limits can be overloaded for user-defined types as well.
Method or Constant | Return | Description |
---|---|---|
is_specialized | bool | |
radix | int | base of exponent |
digits | int | number of radix digits in mantissa |
digits10 | int | number of base 10 digits in mantissa |
is_signed | bool | |
is_integer | bool | |
is_exact | bool | |
min() | <type> | smallest number that can be respresented (not the most negative) |
max() | <type> | largest number |
epsilon() | <type> | inherent representation error value |
round_error() | <type> | maximum rounding adjustment possible |
infinity() | <type> | |
quiet_NaN() | <type> | invalid number that does not signal floating point error |
signaling_NaN() | <type> | invalid number that signals floating point error |
denorm_min() | <type> | |
min_exponent | int | |
min_exponent10 | int | |
max_exponent | int | |
max_exponent10 | int | |
has_infinity | bool | |
has_quiet_NaN | bool | |
has_signaling_NaN | bool | |
has_denorm | <type>_denorm_style | |
has_denorm_loss | bool | |
is_iec559 | bool | conforms to IEC-559 |
is_bounded | bool | |
is_modulo | bool | |
traps | bool | |
tinyness_before | bool | |
round_style | float_round_style { round_to_nearest, … } |
The most common usage is in bounds checking, to determine the minimum and maximum values a data type can hold. The following code prints out the minimum and maximum values for a short on the system it is run.
#include <limits> std::cout << "Maximum short value: " << std::numeric_limits<short>::max() << std::endl; std::cout << "Minimum short value: " << std::numeric_limits<short>::min() << std::endl;
Simple type declarations are easy to understand:
int i
However, it can be tricky to parse more complicated type declarations:
double **d[8] // hmm... char *(*(**foo [][8])())[] // augh! what is foo?
To understand the above declarations, follow three rules:
d
or foo
in the examples above)double
or char
above)For example:
Expression | Meaning |
---|---|
double **d[8]; | |
| d is … double |
| d is an array of 8 … double |
| d is an array of 8 pointer to … double |
| d is an array of 8 pointer to pointer to double |
Another example:
Expression | Meaning |
---|---|
char *(*(**foo [][8])())[] | |
| foo is … char |
| foo is an array of … char |
| foo is an array of an array of 8 … char |
| foo is an array of an array of 8 pointer to … char |
| foo is an array of an array of 8 pointer to pointer to … char |
| foo is an array of an array of 8 pointer to pointer to function returning … char |
| foo is an array of an array of 8 pointer to pointer to function returning pointer to … char |
| foo is an array of an array of 8 pointer to pointer to function returning pointer to array of … char |
| foo is an array of an array of 8 pointer to pointer to function returning pointer to array of pointer to char |
For a much more detailed explanation, see Steve Friedl's excellent description of how to read C declarations at http://www.unixwiz.net/techtips/reading-cdecl.html.