Editing c/data types

{{C Guide}}
The meaning of a value stored in an [[Variables - C|object]] is determined solely by the '''type''' of the expression used to access it - for example the type used in the [[Variables - C#Variable Declaration|variable declaration]]. There are two categories of types:

* '''object types''' - types used to describe objects
* '''function types''' - types used to describe functions

Additionally an object may have a complete or incomplete type. An '''incomplete type''' is a type that describes an object but lacks information needed to determine its size. For example: an array of unknown size or struct or union types whose members were not specified. A '''complete type''' is a type that describes an object with sufficient information needed to determine its size.

== Basic Types ==
Basic types are the fundamental building blocks of all C programs. All basic types are complete types. Basic types are divided into four sub-categories: char type, signed integer types, unsigned integer types, and floating types.

=== Character Types ===
There are three distinct character types: char, signed char, and unsigned char. Depending on the implementation used, a char might be signed or unsigned.

{| class="wikitable sortable"
|-
! Type !! Explanation !! Min Macro !! At least Min Value !! Max Macro !! At least Max Value
|-
| char || Either a "signed char" or a "unsigned char". || colspan=2 | CHAR_MIN || colspan=2 | CHAR_MAX
|-
| signed char || Same as char, guaranteed to be signed. || SCHAR_MIN || -127 || SCHAR_MAX || +127
|-
| unsigned char || Same as char, guaranteed to be unsigned. || 0 || UCHAR_MAX || +255
|}

=== Signed Integer Types ===
The standard defines five signed integer types: 
* signed char
* short int
* int
* long int
* long long int<sup>[[C99]]</sup>

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

{| class="wikitable sortable"
|-
! Type !! Explanation !! Min Macro !! At least Min Value !! Max Macro !! At least Max Value !! since
|-
| short<br />short int<br />signed short<br />signed short int || Short signed integer type.<br />At least 16 bits in size. || SHRT_MIN || -32767 || SHRT_MAX || +32767 || rowspan="3" | [[C89]]
|-
| int<br />signed int || An integer type.<br />At least 16 bits in size. || INT_MIN || -32767 || INT_MAX || +32767
|-
| long<br />long int<br />signed long<br />signed long int || A long integer type.<br />At least 32 bits in size. || LONG_MIN || -2147483647 || LONG_MAX || +2147483647
|-
| long long<br />long long int<br />signed long long<br />signed long long int || A long long integer type.<br />At least 64 bits in size. || LLONG_MIN || -9223372036854775807 || LLONG_MAX || +9223372036854775807 || [[C99]]
|}

The macros in the table can be found in the [[limits.h|<limits.h>]] header.

=== Unsigned Integer Types ===
For each of the signed integer types defined, there is a corresponding unsigned type. Unsigned types are designated with the keyword '''unsigned'''. The unsigned types occupy the same amount of space as their signed counterparts. The range of nonnegative values of a signed integer type is a subrange of the corresponding unsigned type.

Note that unsigned integer types computations can never overflow. Results that cannot be represented by the specified type are reduced modulo the number that is one greater than the largest value that can be represented by that type.


{| class="wikitable sortable"
|-
! Type !! Explanation !! Max Macro !! At least Max Value !! since
|-
| unsigned short<br />unsigned short int || Short unsigned integer type.<br />At least 16 bits in size. || USHRT_MIN || +65535 || rowspan="3" | [[C89]]
|-
| unsigned<br />unsigned int || An unsigned integer type.<br />At least 16 bits in size. || UINT_MAX || +65535
|-
| unsigned long<br />unsigned long int || An unsigned long integer type.<br />At least 32 bits in size. || ULONG_MIN || +4294967295
|-
| unsigned long long<br />unsigned long long int || An unsigned long long integer type.<br />At least 64 bits in size. || ULLONG_MIN || 18446744073709551615 || [[C99]]
|}

The macros in the table can be found in the [[limits.h|<limits.h>]] header.

=== Extended Unsigned/Signed Integer Types ===
Extended signed integer types and extended unsigned integer types are implementation-specific integer types that are provided as an extension to the ones defined by the standard. Although the C standard can't define them or describe their underlying types, it does setup a set of rule by which implementations much conform to in order to ensure well-defined behavior.

== Floating Types ==
Standard C has two types of floating point types: '''real''' and '''complex'''

=== Real Floating Types ===
Standard C provides three real floating types. 
* float
* double
* long double<sup>[[C99]]</sup>

Each type is a subset of the smaller type.

=== Complex Types<sup>C99</sup> ===
Standard C provides three complex types. Complex types are the same as the real floating types with the addition of the '''_Complex''' keyboard. The types are:

== Void Type ==
The '''void type''' comprises an empty set of values. The void type is an [[incomplete type - C|incomplete type]] which cannot be completed. 

* float [[_Complex]]
* double _Complex
* long double _Complex

== Boolean Type<sup>C99</sup> ==
Starting with C99, the C Standard introduced the '''_Bool''' type - an object large enough to store the values 0 and 1.

The standard also introduced a new header: [[stdbool.h|<stdbool.h>]]. It is recommended that the header be used wherever the use of bool is needed instead of using _Bool directly. The header defines 4 macros:

* bool - expands to _Bool
* true - expands to 1
* false - expands to 0
* __bool_true_false_are_ - expands to 1

For example:
<source lang="C">
#include <stdio.h>
#include <stdbool.h>
int main(void)
{
    bool b = true;
    if (b)
        puts("It's true!");
    return 0;
}
</source>

== Enumerated Type ==
An enumerated type is a named integer constant value. An enumeration comprises a set of enumerated types. For example:
<source lang="C">
enum enemies
{
    ghosts = 1,
    goblins,
    octopi,
    monsters
};
</source>

== Array Type ==
An '''array type''' describes a contiguously allocated nonempty set of objects. Each individual element member object is called an element type. The array type is derived from its element type. (For example, if the element type is 'int', the array is said to be an 'array of int'.)

== Structure Type ==
A structure type describes a set of nonempty member objects with an optional name and type.

<source lang="C">
struct student
{
    unsigned int student_id;
    char *first_name;
    char *last_name;
    float gpa;
};
</source>

== Union Type ==
A union type describes a nonempty set of overlapping member objects.

== Function Type ==
A function type describes a function with a specified return type. The number and types of its parameters is used to characterize the function type. 

== Pointer Type ==
A pointer type describes an object whose value provides a reference to an object of a stated type. A pointer type can be derived from both function and object types. 

== Atomic Type <sup>[[C11]]</sup>==
An atomic type describes the type designated by the atomic type specifier. Array types, function types, and qualified types cannot be atomic types.


[[Category:C programming language]]