This articleneeds additional citations forverification. Please helpimprove this article byadding citations to reliable sources. Unsourced material may be challenged and removed. Find sources: "C data types" – news ·newspapers ·books ·scholar ·JSTOR(July 2025) (Learn how and when to remove this message)

In theC programming language,data types constitute the semantics and characteristics of storage of data elements. They are expressed in the language syntax in form of declarations formemory locations orvariables. Data types also determine the types of operations or methods of processing of data elements.

The C language provides basic arithmetic types, such asinteger andreal number types, and syntax to build array and compound types. TheC standard library contains additional definitions of support types, that have additional properties, such as providing storage with an exact size, independent of the language implementation on specific hardware platforms.^[1][2]

The C language provides the four basic arithmetic type specifierschar,int,float anddouble (as well as the Boolean typebool), and the modifierssigned,unsigned,short, andlong. The following table lists the permissible combinations in specifying a large set of storage size-specific declarations.

The actual size of theinteger types varies by implementation. The standard requires only size relations between the data types and minimum sizes for each data type:

The relation requirements are that thelong long is not smaller thanlong, which is not smaller thanint, which is not smaller thanshort. Aschar's size is always the minimum supported data type, no other data types (exceptbit-fields) can be smaller.

The minimum size forchar is 8 bits, the minimum size forshort andint is 16 bits, forlong it is 32 bits andlong long must contain at least 64 bits.

The typeint should be the integer type that the target processor is most efficiently working with. This allows great flexibility: for example, all types can be 64-bit. However, several different integer width schemes (data models) are popular. Because the data model defines how different programs communicate, a uniform data model is used within a given operating system application interface.^[10]

In practice,char is usually 8 bits in size andshort is usually 16 bits in size (as are their unsigned counterparts). This holds true for platforms as diverse as 1990sSunOS 4 Unix, MicrosoftMS-DOS, modernLinux, and Microchip MCC18 for embedded 8-bit PICmicrocontrollers.POSIX requireschar to be exactly 8 bits in size.^[11][12]

Various rules in the C standard makeunsigned char the basic type used for arrays suitable to store arbitrary non-bit-field objects: its lack of padding bits and trap representations, the definition ofobject representation,^[8] and the possibility of aliasing.^[13]

The actual size and behavior of floating-point types also vary by implementation. The only requirement is thatlong double is not smaller thandouble, which is not smaller thanfloat. Usually, the 32-bit and 64-bitIEEE 754 binary floating-point formats are used forfloat anddouble respectively.

TheC99 standard includes new real floating-point typesfloat_t anddouble_t, defined in<math.h>. They correspond to the types used for the intermediate results of floating-point expressions whenFLT_EVAL_METHOD is 0, 1, or 2. These types may be wider thanlong double.

C99 also addedcomplex types:float _Complex,double _Complex,long double _Complex.C11 addedimaginary types (which were described in an informative annex of C99):float _Imaginary,double _Imaginary,long double _Imaginary. Including the header<complex.h> allows all these types to be accessed with usingcomplex andimaginary respectively.

C99 added aBoolean data type_Bool. Additionally, the<stdbool.h> header definesbool as a convenient alias for this type, and also provides macros fortrue andfalse._Bool functions similarly to a normal integer type, with one exception: any conversion to a_Bool gives 0 (false) if the value equals 0; otherwise, it gives 1 (true). This behavior exists to avoidinteger overflows in implicit narrowing conversions. For example, in the following code:

unsignedcharb=256;if(b){// do something}

Variableb evaluates to false ifunsigned char has a size of 8 bits. This is because the value 256 does not fit in the data type, which results in the lower 8 bits of it being used, resulting in a zero value. However, changing the type causes the previous code to behave normally:

_Boolb=256;if(b){// do something}

The type_Bool also ensures true values always compare equal to each other:

_Boola=1;_Boolb=2;if(a==b){// this code will run}

InC23,bool (and its valuestrue andfalse) became a core functionality of the language (making the contents of<stdbool.h> obsolescent^[14][15]), allowing for the following examples of code:

boolb=true;if(b){// this code will run}

SinceC23, the language allows the programmer to define integers that have a width of an arbitrary number of bits. Those types are specified as_BitInt(N), whereN is an integer constant expression that denotes the number of bits, including the sign bit for signed types, represented in two's complement. The maximum value ofN is provided byBITINT_MAXWIDTH and is at leastULLONG_WIDTH. Therefore, the type_BitInt(2) (orsigned_BitInt(2)) takes values from −2 to 1 whileunsigned_BitInt(2) takes values from 0 to 3. The typeunsigned_BitInt(1) also exists, being either 0 or 1 and has no equivalent signed type.^[16] A proposal forC2Y proposes to lift this restriction and allowsigned_BitInt(1) which then has the possible values 0 and -1, removing the special case forunsigned_BitInt(1).^[17]

The C language specification includes thetypedefssize_t andptrdiff_t to represent memory-related quantities. Their size is defined according to the target processor's arithmetic capabilities, not the memory capabilities, such as available address space. Both of these types are defined in the<stddef.h> header.

size_t is an unsigned integer type used to represent the size of any object (including arrays) in the particular implementation. The operatorsizeof yields a value of the typesize_t. The maximum size ofsize_t is provided viaSIZE_MAX, a macro constant which is defined in the<stdint.h> header.size_t is guaranteed to be at least 16 bits wide. Additionally, POSIX includesssize_t, which is a signed integer type of the same width assize_t.

ptrdiff_t is a signed integer type used to represent the difference between pointers. It is guaranteed to be valid only against pointers of the same type; subtraction of pointers consisting of different types is implementation-defined.

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

• CHAR_BIT – size of the char type in bits, commonly referred to as the size of abyte (at least 8 bits)
• SCHAR_MIN,SHRT_MIN,INT_MIN,LONG_MIN,LLONG_MIN(C99) – minimum possible value of signed integer types: signed char, signed short, signed int, signed long, signed long long
• SCHAR_MAX,SHRT_MAX,INT_MAX,LONG_MAX,LLONG_MAX(C99) – maximum possible value of signed integer types: signed char, signed short, signed int, signed long, signed long long
• UCHAR_MAX,USHRT_MAX,UINT_MAX,ULONG_MAX,ULLONG_MAX(C99) – maximum possible value of unsigned integer types: unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long
• CHAR_MIN – minimum possible value of char
• CHAR_MAX – maximum possible value of char
• MB_LEN_MAX – maximum number of bytes in a multibyte character
• BOOL_WIDTH (C23) - bit width of_Bool, always 1
• CHAR_WIDTH (C23) - bit width ofchar;CHAR_WIDTH,UCHAR_WIDTH andSCHAR_WIDTH are equal toCHAR_BIT by definition
• SCHAR_WIDTH,SHRT_WIDTH,INT_WIDTH,LONG_WIDTH,LLONG_WIDTH (C23) - bit width ofsigned char,short,int,long, andlong long respectively
• UCHAR_WIDTH,USHRT_WIDTH,UINT_WIDTH,ULONG_WIDTH,ULLONG_WIDTH (C23) - bit width ofunsigned char,unsigned short,unsigned int,unsigned long, andunsigned long long respectively

• FLT_MIN,DBL_MIN,LDBL_MIN – minimum normalized positive value of float, double, long double respectively
• FLT_TRUE_MIN,DBL_TRUE_MIN,LDBL_TRUE_MIN (C11) – minimum positive value of float, double, long double respectively
• FLT_MAX,DBL_MAX,LDBL_MAX – maximum finite value of float, double, long double, respectively
• FLT_ROUNDS – rounding mode for floating-point operations
• FLT_EVAL_METHOD (C99) – evaluation method of expressions involving different floating-point types
• 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 float, double, long double, respectively
• FLT_EPSILON,DBL_EPSILON,LDBL_EPSILON –difference between 1.0 and the next representable value of float, double, long double, respectively
• FLT_MANT_DIG,DBL_MANT_DIG,LDBL_MANT_DIG – number ofFLT_RADIX-base digits in the floating-point significand for types float, double, long double, respectively
• FLT_MIN_EXP,DBL_MIN_EXP,LDBL_MIN_EXP – minimum negative integer such thatFLT_RADIX raised to a power one less than that number is a normalized float, double, long double, respectively
• FLT_MIN_10_EXP,DBL_MIN_10_EXP,LDBL_MIN_10_EXP – minimum negative integer such that 10 raised to that power is a normalized float, double, long double, respectively
• FLT_MAX_EXP,DBL_MAX_EXP,LDBL_MAX_EXP – maximum positive integer such thatFLT_RADIX raised to a power one less than that number is a normalized float, double, long double, respectively
• FLT_MAX_10_EXP,DBL_MAX_10_EXP,LDBL_MAX_10_EXP – maximum positive integer such that 10 raised to that power is a normalized float, double, long double, respectively
• DECIMAL_DIG (C99) – minimum number of decimal digits such that any number of the widest supported floating-point type can be represented in decimal with a precision ofDECIMAL_DIG digits and read back in the original floating-point type without changing its value.DECIMAL_DIG is at least 10.

TheC99 standard includes definitions of several new integer types to enhance the portability of programs.^[2] The already available basic integer types were deemed insufficient, because their actual sizes are implementation defined and may vary across different systems. The new types are especially useful inembedded environments where hardware usually supports only several types and that support varies between different environments. All new types are defined in<inttypes.h> header and also are available at<stdint.h> header. The types can be grouped into the following categories:

• Exact-width integer types that are guaranteed to have the same numbern of bits across all implementations. Included only if it is available in the implementation.
• Least-width integer types that are guaranteed to be the smallest type available in the implementation, that has at least specified numbern of bits. Guaranteed to be specified for at least N=8,16,32,64.
• Fastest integer types that are guaranteed to be the fastest integer type available in the implementation, that has at least specified numbern of bits. Guaranteed to be specified for at least N=8,16,32,64.
• Pointer integer types that are guaranteed to be able to hold a pointer. Included only if it is available in the implementation.
• Maximum-width integer types that 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):

The<inttypes.h> header provides features that enhance the functionality of the types defined in the<stdint.h> header. It defines macros forprintf format string andscanf format string specifiers corresponding to the types defined in<stdint.h> and several functions for working with theintmax_t anduintmax_t types. This header was added inC99.

The macros are in the formatPRI{fmt}{type}. Here{fmt} defines the output formatting and is one ofd (decimal),x (hexadecimal),o (octal),u (unsigned) andi (integer).{type} defines the type of the argument and is one ofn,FASTn,LEASTn,PTR,MAX, wheren corresponds to the number of bits in the argument.

The macros are in the formatSCN{fmt}{type}. Here{fmt} defines the output formatting and is one ofd (decimal),x (hexadecimal),o (octal),u (unsigned) andi (integer).{type} defines the type of the argument and is one ofn,FASTn,LEASTn,PTR,MAX, wheren corresponds to the number of bits in the argument.

This sectionneeds expansion. You can help byadding missing information.(October 2011)

Similarly to the fixed-width integer types, ISO/IEC TS 18661 specifies floating-point types for IEEE 754 interchange and extended formats in binary and decimal:

• _FloatN for binary interchange formats;
• _DecimalN for decimal interchange formats;
• _FloatNx for binary extended formats;
• _DecimalNx for decimal extended formats.

Every data typeT has a corresponding typepointer-to-T. Apointer is a data type that contains the address of a storage location of a variable of a particular type. They are declared with the asterisk (*) type declarator following the basic storage type and preceding the variable name. Whitespace before or after the asterisk is optional.

char*p;long*q;int*r;

Pointers may also be declared for pointer data types, thus creating multiple indirect pointers, such aschar ** andint ***, including pointers to array types. The latter are less common than an array of pointers, and their syntax may be confusing:

char*pc[10];// array of 10 elements of 'pointer to char'char(*pa)[10];// pointer to a 10-element array of char

The elementpc requires ten blocks of memory of the size ofpointer-to-char (usually 40 or 80 bytes on common platforms), but elementpa is only one pointer (size 4 or 8 bytes), and the data it refers to is an array of ten bytes (sizeof*pa==10).

C also has a "pointer-to-void",void *.^[18] The name "pointer-to-void" does not imply it points tovoid memory (asvoid is an incomplete type with no size), but rather that it points to something of unspecified type. It must be converted to another pointer type before it can be dereferenced. Avoid * may not point to a function. A call tomalloc returnsvoid *, andfree takes avoid *.

C uses the concept of anull pointer to denote a pointer that does not refer to any valid data. The macroNULL is often used in place of a null pointer, relying on implicit type conversion when possible. However, this usage can be problematic and may be a source of programming errors. In particular, the expansion ofNULL may have a pointer type or an integer type, depending on the implementation.C23 introduced the predefined constantnullptr and its typenullptr_t (which has the single valuenullptr) to express a null pointer constant.nullptr is unambiguously a pointer, and may convert to any object or function pointer, and allows a specificnullptr_t case in_Generic.^[19] The size and alignment of this type is the same as for a pointer to character type (orvoid *), but other pointer types may still have a different size and alignment; thus not all null pointers are replaceable withnullptr.^[20]

For every typeT, exceptvoid and function types, there exist the types"array ofN elements of typeT". An array is a collection of values, all of the same type, stored contiguously in memory. An array of sizeN is indexed by integers from0 up to and includingN − 1. Here is a brief example:

inta[10];// array of 10 elements, each of type int

Arrays can be initialized with a compound initializer, but not assigned. Arrays are passed to functions by passing a pointer to the first element. Multidimensional arrays are defined as"array of array ...", and all except the outermost dimension must have compile-time constant size:

intaa[10][8];// array of 10 elements, each of type 'array of 8 int elements'

In C, a string is often stored as an array ofchar (char[]), but this is distinct from a pointer-to-char (char *).char[] cannot be reassigned, and lives where it is defined, whilechar * is reassignable, but cannot be modified.

chars[]="Hello, world!";char*p=s;// s decays to &s[0], p points to the first character

Even if a function takesT[] as a parameter, it decays into aT * which points to its first element.

voidf(inta[]);// this is the same as:voidf(int*a);

Indexing an array is defined in terms ofpointer arithmetic, that is,a[i] is equivalent to*(a + i).^[21]

In C, an enum is an integer type whose values are restricted to a set of named constants.^[22] Enums cannot be forward-declared. Enums may also directly be assigned values, and are commonly used withswitch to enumerate multiple cases.

#include<stddef.h>enumStatus{OK=200,NOT_FOUND=404,SERVER_ERROR=500};constchar*get_status_string(enumStatusstatus){switch(status){caseOK:return"Success";caseNOT_FOUND:return"Not found";caseSERVER_ERROR:return"Server error";default:unreachable();}}

Enum constants are known at compile time, and are often a safer means to define integral constants than macros. An enum's underlying size is usuallyint, but since C23 an enum's underlying size can be directly specified to be any integral type.

enumColor:char{RED=1,ORANGE,YELLOW,GREEN,BLUE,INDIGO,VIOLET};

Because enums are not type-safe, they can be assigned a value of another enum. Enums also need not be assigned values necessarily within the range of defined values.

enumColorcolor=YELLOW;// YELLOW = 3enumMonthmonth=JUNE;// JUNE = 6color=month;// color is now 6 (INDIGO)month=999;// there may not be a value of 999 in enum Month, but still allowed

Structures (structs) aggregate the storage of multiple data items, of potentially differing data types, into one contiguous memory block referenced by a single variable. Members may possibly be padded formemory alignment, and thus it is often recommended to order fields from largest to smallest size for efficient memory usage.

structStudent{charname[50];unsignedintid;unsignedintsemester;floatgpa;};// Positional initialization - values matches field orderstructStudentalice={"Alice",123,2,3.8};// Designated initializer (since C99)structStudentbob={.name="Bob",.id=246,.semester=1,.gpa=3.9};

Structs may also usebit fields to allow fields to share the same storage units, but layouts are implementation-defined.

structProperties{// three fields can be compactly packed in one byteunsignedcharvisible:1;// a occupies 1 bitunsignedcharcolor:3;// b occupies 3 bitsunsignedcharsize:4;// c occupies 4 bits};

The memory layout of a struct is a language implementation issue for each platform, with a few restrictions. The memory address of the first member must be the same as the address of structure itself. Structs may beinitialized or assigned to using compound literals. A function may directly return a struct, although this is often not efficient at run-time. SinceC99, a struct may also end with aflexible array member.

Functions may take a struct as a parameter by value, but this is expensive as it copies the entire struct. Meanwhile, passing it by pointer is often preferable as the size of a pointer is known (typically 4 or 8 bytes).

#include<stdio.h>// passing by valuevoidprint_student(structStudents){printf("Name: %s, ID: %d, in semester %d, with GPA: %.2f\n",s.name,s.id,s.semester,s.gpa);}// passing by pointervoidprint_student(structStudent*s){printf("Name: %s, ID: %d, in semester %d, with GPA: %.2f\n",s->name,s->id,s->semester,s->gpa);}

Structs can be composed of other structs:

structDate{intyear;intmonth;intday;};structBirthday{charname[50];structDatedob;};

A struct containing a pointer to a struct of its own type is commonly used to buildlinked data structures:

structLinkedList{void*item;// stores the current itemstructLinkedList*next;// stores the next list, or NULL if nothing next};

Aunion type is a special construct that permits access to the same memory block by using a choice of differing type descriptions.

// holds either an integer or floating point valueunionNumber{inti;floatf;}d;d.i=10;// d now holds 10d.f=3.14f;// d now holds 3.14, overwriting 10

In the following example, a union of data types may be declared to permit reading the same data either as an integer, a float, or any other user declared type:

union{inti;floatf;struct{unsignedintu;doubled;}s;}u;

The total size ofu is the size ofu.s – which happens to be the sum of the sizes ofu.s.u andu.s.d – sinces is larger than bothi andf. When assigning something tou.i, some parts ofu.f may be preserved ifu.i is smaller thanu.f.

Reading from a union member is not the same as casting since the value of the member is not converted, but merely read.

Function pointers allow referencing functions with a particular signature. For example, to store the address of the standard functionabs in the variablemy_int_f:

int(*my_int_f)(int)=&abs;// the & operator can be omitted, but makes clear that the "address of" abs is used here

Function pointers are invoked by name just like normal function calls.

#include<stdio.h>#include<stdlib.h>int(*my_abs)(int)=&abs;intx=-42;intabs_of_x=my_abs(x);printf("abs(%d) = %d\n",x,abs_of_x);

The aforementioned types can be characterized further bytype qualifiers, yielding aqualified type. As of 2014^[update] andC11, there are four type qualifiers in standard C:

• const (C89)
• volatile (C89)
• restrict (C99)
• _Atomic (C11) – the latter has a private name to avoid clashing with user names,^[23] but the more ordinary nameatomic can be used if the<stdatomic.h> header is included.

Of these,const is by far the best-known and most used^{[citation needed]}, appearing in theC standard library and encountered in any significant use of the C language, which must satisfyconst-correctness. The other qualifiers are primarily used for low-level programming:volatile is intended suppress compiler optimisations on a variable by suggesting it may change at any time,restrict indicates that the object pointed to by a pointer is accessed only by that pointer, and_Atomic indicates that the object is "atomic", i.e. reads and writes are indivisible.

The WikibookC Programming has a page on the topic of:Variables

• C syntax
• Uninitialized variable
• Integer (computer science)
• Offsetof

• C (programming language)
• C standard library
• Data types

• Articles with short description
• Short description is different from Wikidata
• Use dmy dates from July 2021
• Articles needing additional references from July 2025
• All articles needing additional references
• Articles to be expanded from October 2011
• All articles to be expanded
• Articles containing potentially dated statements from 2014
• All articles containing potentially dated statements
• All articles with unsourced statements
• Articles with unsourced statements from September 2015
• Articles with example C code