C variable types and declarations - AbsoluteAstronomy.com

C (programming language)

C is a general-purpose computer programming language developed between 1969 and 1973 by Dennis Ritchie at the Bell Telephone Laboratories for use with the Unix operating system....

, data types refers to an extensive system for declaring variables of different types. The language itself provides basic arithmetic types and syntax to build array and compound types. Several headers in the standard library

C standard library

The C Standard Library is the standard library for the programming language C, as specified in the ANSI C standard.. It was developed at the same time as the C POSIX library, which is basically a superset of it...

contain definitions of support types, that have additional properties, such as exact size, guaranteed.

Basic types

The C language provides a lot of basic types. Most of them are formed from one of the four basic arithmetic type identifiers in C (char, int, float and double), and optional specifiers (signed, unsigned, short, long). All available basic arithmetic types are listed below:

Type	Explanation	Type	Explanation
	smallest addressable unit of the machine that can contain basic character set. It is an integer type. Actual type can be either signed or unsigned depending on implementation		same as `char`, but guaranteed to be signed.
			same as `char`, but guaranteed to be unsigned.
	short signed integer type. At least 16 bits in size.		same as `short`, but unsigned.
	basic signed integer type. At least 16 bits in size.		same as `int`, but unsigned.
	long signed integer type. At least 32 bits in size.		same as `long`, but unsigned.
	long long signed integer type. At least 64 bits in size. Specified only in C99 C99 C99 is a modern dialect of the C programming language. It extends the previous version with new linguistic and library features, and helps implementations make better use of available computer hardware and compiler technology.-History:... version of the standard.		same as `long long`, but unsigned. Specified only in C99 C99 C99 is a modern dialect of the C programming language. It extends the previous version with new linguistic and library features, and helps implementations make better use of available computer hardware and compiler technology.-History:... version of the standard.
	single precision floating-point type. Actual properties unspecified, however on most systems this is IEEE 754 single precision floating point format Single precision floating-point format Single-precision floating-point format is a computer number format that occupies 4 bytes in computer memory and represents a wide dynamic range of values by using a floating point.... .
	double precision floating-point type. Actual properties unspecified, however on most systems this is IEEE 754 double precision floating point format.
	extended precision floating-point type. Actual properties unspecified. On most systems this is equivalent either to , 80-bit floating point format Extended precision The term extended precision refers to storage formats for floating point numbers not falling into the regular sequence of single, double, and quadruple precision formats... , or IEEE 754 quadruple precision floating-point format Quadruple precision floating-point format In computing, quadruple precision is a binary floating-point computer number format that occupies 16 bytes in computer memory.... .

The actual size of integer types varies by implementation. The only guarantee is that the long long is not smaller than long, which is not smaller than int, which is not smaller than short. Also, int should be the integer type that the target processor is most efficient working with. This allows great flexibility: for example, all types can be 64-bit. However, only several different integer width schemes (data models) are popular and since data model defines how different programs communicate, a uniform data model is used within a given operating system application interface.

The actual size of floating point types also varies by implementation. The only guarantee is that the long double is not smaller than double, which is not smaller than float. Usually, 32-bit and 64-bit IEEE 754 floating point formats are used.

Boolean type

The C language did not have a boolean type until the C99

C99

C99 is a modern dialect of the C programming language. It extends the previous version with new linguistic and library features, and helps implementations make better use of available computer hardware and compiler technology.-History:...

version of the standard. In C99 the boolean variable has been added as _Bool. Additionally, a new header stdbool.h has been added for compatibility reasons. This header allows programmers to use boolean types in the same way, as in C++ language. The missing identifiers are defined as macros - bool is defined as _Bool, true as 1, false as 0. Additionally, __bool_true_false_are_defined is defined as 1.

Size and pointer difference types

The C language provides the separate types size_t and ptrdiff_t to represent memory related quantities. Existing types were deemed insufficient, because their size is defined according to the target processor arithmetic capabilities, not the memory capabilities. Both of these types are defined in stddef.h header (cstddef header in C++). size_t is used to represent the maximum size of any object (including arrays) in the particular implementation. It is used as the return type of sizeof operator. ptrdiff_t is used to represent difference between pointers.

Interface to the properties of the basic types

Information about the actual properties, such as size, of the basic arithmetic types, is provided via macro constants in two headers: limits.h header (climits header in C++) defines macros for integer types and float.h header (cfloat header in C++) defines macros for floating-point types. The actual values depend on the implementation.

Properties of integer types

CHAR_BIT - size of the type in bits (it is not necessarily 8 bits)
SCHAR_MIN, SHRT_MIN, INT_MIN, LONG_MIN, LLONG_MIN(C99) - minimum possible value of signed integer types: , , , ,
SCHAR_MAX, SHRT_MAX, INT_MAX, LONG_MAX, LLONG_MAX(C99) - maximum possible value of signed integer types: , , , ,
UCHAR_MAX, USHRT_MAX, UINT_MAX, ULONG_MAX, ULLONG_MAX(C99) - maximum possible value of unsigned integer types: , , , ,
CHAR_MIN - minimum possible value of
CHAR_MAX - maximum possible value of
MB_LEN_MAX - maximum number of bytes in a multibyte character

Properties of floating-point types

FLT_MIN, DBL_MIN, LDBL_MIN - minimum value of , , respectively
FLT_MAX, DBL_MAX, LDBL_MAX - maximum value of , , respectively
FLT_ROUNDS - rounding mode for floating-point operations
FLT_EVAL_METHOD - evaluation method of expressions involving different floating-point types (only available in C99)
FLT_RADIX - radix of the exponent in the floating-point types
FLT_DIG, DBL_DIG, LDBL_DIG - number of decimal digits that can be represented without losing precision by , , respectively
FLT_EPSILON, DBL_EPSILON, LDBL_EPSILON - difference between 1.0 and the next representable value of , , respectively
FLT_MANT_DIG, DBL_MANT_DIG, LDBL_MANT_DIG - number of FLT_RADIX-base digits in the floating-point mantissa for types , , respectively
FLT_MIN_EXP, DBL_MIN_EXP, LDBL_MIN_EXP - minimum negative integer such that FLT_RADIX raised to a power one less than that number is a normalized , , respectively
FLT_MIN_10_EXP, DBL_MIN_10_EXP, LDBL_MIN_10_EXP - minimum negative integer such that 10 raised to a power one less than that number is a normalized , , respectively
FLT_MAX_EXP, DBL_MAX_EXP, LDBL_MAX_EXP - maximum positive integer such that FLT_RADIX raised to a power one more than that number is a normalized , , respectively
FLT_MAX_10_EXP, DBL_MAX_10_EXP, LDBL_MAX_10_EXP - maximum positive integer such that 10 raised to a power one more than that number is a normalized , , respectively
DECIMAL_DIG - minimum number of decimal digits needed to represent all the significant digits for . The value is at least 10. (only available in C99)

Fixed width integer types

The C99

C99

standard includes definitions of several new integer types to enhance the portability of programs. The already available basic integer types were deemed insufficient, because their actual sizes are implementation defined and may be vary across different systems. The new types are especially useful in embedded environments

Embedded system

An embedded system is a computer system designed for specific control functions within a larger system. often with real-time computing constraints. It is embedded as part of a complete device often including hardware and mechanical parts. By contrast, a general-purpose computer, such as a personal...

where hardware supports usually only several types and that support varies from system to system. All new types are defined in inttypes.h header (cinttypes header in C++) and also are available at stdint.h header (cstdint header in C++). The types can be grouped into the following categories:

Exact width integer types which are guaranteed to have the same number N of bits across all implementations. Included only if it is available in the implementation.
Least width integer types which are guaranteed to be the smallest type available in the implementation, that has at least specified number N of bits. Guaranteed to be specified for at least N=8,16,32,64.
Fastest integer types which are guaranteed to be the fastest integer type available in the implementation, that has at least specified number N of bits. Guaranteed to be specified for at least N=8,16,32,64.
Pointer integer types which are guaranteed to be able to hold a pointer
Maximum width integer types which are guaranteed to be the largest integer type in the implementation

The following table summarizes the types and the interface to acquire the implementation details (N refers to the number of bits):

Type category	Signed types			Unsigned types
Type category	Type	Minimum value	Maximum value	Type	Minimum value	Maximum value
Exact width	`intN_t`	`INTN_MIN`	`INTN_MAX`	`uintN_t`	0	`UINTN_MAX`
Least width	`int_leastN_t`	`INT_LEASTN_MIN`	`INT_LEASTN_MAX`	`uint_leastN_t`	0	`UINT_LEASTN_MAX`
Fastest	`int_fastN_t`	`INT_FASTN_MIN`	`INT_FASTN_MAX`	`uint_fastN_t`	0	`UINT_FASTN_MAX`
Pointer	`intptr_t`	`INTPTR_MIN`	`INTPTR_MAX`	`uintptr_t`	0	`UINTPTR_MAX`
Maximum width	`intmax_t`	`INTMAX_MIN`	`INTMAX_MAX`	`uintmax_t`	0	`UINTMAX_MAX`

Printf and scanf format specifiers

The inttypes.h header (cinttypes header in C++) provides features that enhances the functionality of the types defined in stdint.h header. The included things are macros that define printf format string and scanf format string specifiers corresponding to the stdint.h types and several functions for working with intmax_t and uintmax_t types. This header is available only in C99

C99

version of the standard.

Printf format string

All defined macros are in the following format: PRI{fmt}{type}. Here {fmt} defines the output formatting and is one of d (decimal), x (hexadecimal), o (octal), u (unsigned) and i (integer). {type} defines the type of the argument and is one of N, FASTN, LEASTN, PTR, MAX, where N corresponds to the number of bits in the argument.
Scanf format string

All defined macros are in the following format: SCN{fmt}{type}. Here {fmt} defines the output formatting and is one of d (decimal), x (hexadecimal), o (octal), u (unsigned) and i (integer). {type} defines the type of the argument and is one of N, FASTN, LEASTN, PTR, MAX, where N corresponds to the number of bits in the argument.

Functions

Structures

Structures are a way of storing multiple pieces of data in one variable. For example, say we wanted to store the name and birthday of a person in strings, in one variable. We could use a structure to house that data:

struct birthday {
char name[20];
int day;
int month;
int year;
};

Structures may contain pointers to structs of its own type, which is common in linked datastructures

Linked data structure

In computer science, a linked data structure is a data structure which consists of a set of data records linked together and organized by references ....

.

A C implementation has freedom to design the memory layout of the struct, with few restrictions; one being that the memory address of the first member will be the same as the address of struct itself. Structs may be initialized or assigned to using compound literals.

Arrays

An array is a collection of values, all of the same type, stored contiguously in memory. An array of size N is indexed by integers from 0 up to and including N-1.

For example:

int cat[10];

Arrays can be initialized with a compound initializer, but not assigned. Arrays are passed to functions by passing a pointer to the first element.

Pointer types

Variables can be declared as being pointers to values of various types, by means of the * type declarator. To declare a variable as a pointer, immediately precede its name with an asterisk.

char *square;
long *circle;

Function pointers

Function pointers allow referencing functions with a particular signature. For example, to store the address of the standard function abs in our variable my_int_f:

int (*my_int_f)(int) = abs;

Function pointers are invoked by name just like normal function calls. Function pointers are separate from pointers and the void * pointer type.