C Programming/Language Reference
Table of keywords
editANSI (American National Standards Institute) C (C89)/ISO C (C90)
editVery old compilers may not recognize some or all of the C89 keywords const
, enum
, signed
, void
, volatile
, as well as any later standards' keywords.
|
|
|
|
ISO C (C99)
editThese are supported in most new compilers.
|
|
ISO C (C11)
editThese are supported only in some newer compilers
|
|
|
Although not technically a keyword, C99-capable preprocessors/compilers additionally recognize the special preprocessor operator _Pragma
, which acts as an alternate form of the #pragma
directive that can be used from within macro expansions. For example, the following code will cause some compilers (incl. GCC, Clang) to emit a diagnostic message:
#define EMIT_MESSAGE(str) EMIT_PRAGMA(message(str))
#define EMIT_PRAGMA(content) _Pragma(#content)
EMIT_MESSAGE("Hello, world!")
Some compilers use a slight variant syntax; in particular, MSVC supports __pragma
instead of _Pragma
.
Specific compilers may also—in a non-standards-compliant mode, or with additional syntactic markers like __extension__
—treat some other words as keywords, including asm
, cdecl
, far
, fortran
, huge
, interrupt
, near
, pascal
, or typeof
. However, they typically allow these keywords to be overridden by declarations when operating in standards-compliant modes (e.g., by defining a variable named typeof
), in order to avoid introducing incompatibilities with existing programs. In order to ensure the compiler can maintain access to extension features, these compilers usually have an additional set of proper keywords beginning with two underscores (__
). For example, GCC treats asm
, __asm
, and __asm__
somewhat identically, but the latter two are always guaranteed to have the expected meaning since they can't be overridden.
Many of the newly introduced keywords—namely, those beginning with an underscore and capital letter like _Noreturn
or _Imaginary
—are intended to be used only indirectly in most situations. Instead, the programmer should prefer the use of standard headers such as <stdbool.h>
or <stdalign.h>
, which typically use the preprocessor to establish an all-lower-case variant of the keyword (e.g.,
or complex
). These headers serve the purpose of enabling C and C++ code, as well as code targeting different compilers or language versions, to interoperate more cleanly. For example, by including noreturn
<stdbool.h>
, the tokens
, bool
, and true
can be used identically in either C99 or C++ without having to explicitly use false
_Bool
in C99 or bool
in C++.
See also the list of reserved identifiers [1].
Table of operators
editOperators in the same row of this table have the same precedence and the order of evaluation is decided by the associativity (left-to-right or right-to-left). Operators closer to the top of this table have higher precedence than those in a subsequent group.
Operators | Description | Example Usage | Associativity |
---|---|---|---|
Postfix operators | Left to right | ||
() |
function call operator | swap (x, y)
| |
[] |
array index operator | arr [i]
| |
. |
member access operator for an object of struct/union type or a reference to it |
obj.member
| |
-> |
member access operator for a pointer to an object of struct/union type |
ptr->member
| |
Unary Operators | Right to left | ||
! |
logical not operator | !eof_reached
| |
~ |
bitwise not operator | ~mask
| |
+ - [2]
|
unary plus/minus operators | -num
| |
++ -- |
post-increment/decrement operators | num++
| |
++ -- |
pre-increment/decrement operators | ++num
| |
& |
address-of operator | &data
| |
* |
indirection operator | *ptr
| |
sizeof |
sizeof operator for expressions | sizeof 123
| |
sizeof() |
sizeof operator for types | sizeof (int)
| |
(type) |
cast operator | (float)i
| |
Multiplicative Operators | Left to right | ||
* / % |
multiplication, division and modulus operators |
celsius_diff * 9.0 / 5.0
| |
Additive Operators | Left to right | ||
+ - |
addition and subtraction operators | end - start + 1
| |
Bitwise Shift Operators | Left to right | ||
<< |
left shift operator | bits << shift_len
| |
>> |
right shift operator | bits >> shift_len
| |
Relational Inequality Operators | Left to right | ||
< > <= >= |
less-than, greater-than, less-than or equal-to, greater-than or equal-to operators |
i < num_elements
| |
Relational Equality Operators | Left to right | ||
== != |
equal-to, not-equal-to | choice != 'n'
| |
Bitwise And Operator | Left to right | ||
& |
bits & clear_mask_complement
| ||
Bitwise Xor Operator | Left to right | ||
^ |
bits ^ invert_mask
| ||
Bitwise Or Operator | Left to right | ||
| |
bits | set_mask
| ||
Logical And Operator | Left to right | ||
&& |
arr != 0 && arr->len != 0
| ||
Logical Or Operator | Left to right | ||
|| |
arr == 0 || arr->len == 0
| ||
Conditional Operator | Right to left | ||
?: |
size != 0 ? size : 0
| ||
Assignment Operators | Right to left | ||
= |
assignment operator | i = 0
| |
+= -= *= /=
|
shorthand assignment operators ( foo op= bar representsfoo = foo op bar ) |
num /= 10
| |
Comma Operator | Left to right | ||
, |
i = 0, j = i + 1, k = 0
|
Table of data types
editType | Size in Bits | Comments | Alternative Names |
---|---|---|---|
Primitive Types in ANSI C (C89)/ISO C (C90) | |||
char |
≥ 8 |
|
— |
signed char |
same as char
|
|
— |
unsigned char |
same as char
|
|
— |
short |
≥ 16, ≥ size of char
|
|
short int , signed short , signed short int
|
unsigned short |
same as short
|
|
unsigned short int
|
int |
≥ 16, ≥ size of short
|
|
signed , signed int
|
unsigned int |
same as int
|
|
unsigned
|
long |
≥ 32, ≥ size of int
|
|
long int , signed long , signed long int
|
unsigned long |
same as long
|
|
unsigned long int
|
float |
≥ size of char
|
|
— |
double |
≥ size of float
|
|
— |
long double |
≥ size of double
|
|
— |
Primitive Types added to ISO C (C99) | |||
long long |
≥ 64, ≥ size of long
|
|
long long int , signed long long , signed long long int
|
unsigned long long |
same as long long
|
|
unsigned long long int
|
intmax_t |
the maximum width supported by the platform |
|
— |
uintmax_t |
same as intmax_t
|
|
— |
User Defined Types | |||
struct |
≥ sum of size of each member |
|
— |
union |
≥ size of the largest member |
|
— |
enum |
≥ size of char
|
|
— |
typedef |
same as the type being given a name |
|
— |
Derived Types[7] | |||
type* (pointer) |
≥ size of char
|
|
— |
type [integer[8]] (array) |
≥ integer × size of type
|
|
— |
type (comma-delimited list of types/declarations) (function) |
— |
|
— |
Character sets
editPrograms written in C can read and write any character set, provided the libraries that support them are included/used.
The source code for C programs, however, is usually limited to the ASCII character set.
In a file containing source code, the end of a line is sometimes, depending on the operating system it was created on not a newline character but compilers treat the end of each line as if it were a single newline character.
Virtually all compilers allow the $, @, and ` characters in string constants. Many compilers also allow literal multibyte Unicode characters, but they are not portable.
Certain characters must be escaped with a backslash to represent themselves in a string or character constant. These are:
|
|
|
Additionally, some compilers allow these characters:
\r
Carriage return\a
Alert (audible bell)\b
Backspace
\xhh, where the 'h' characters are hexadecimal digits, is used to represent arbitrary bytes (including \x00, the zero byte).
\uhhhh or \Uhhhhhhhh, where the 'h' characters are hexadecimal digits, is used to portably represent Unicode characters.
References
edit- ↑ http://publib.boulder.ibm.com/infocenter/comphelp/v7v91/topic/com.ibm.vacpp7a.doc/language/ref/clrc02reserved_identifiers.htm list of reserved identifiers
- ↑ Very old compilers may not recognize the unary
+
operator. - ↑ -128 can be stored in two's-complement machines (i.e. most machines in existence). Very old compilers may not recognize the
signed
keyword - ↑ a b -32768 can be stored in two's-complement machines (i.e. most machines in existence). Very old compilers may not recognize the
signed
keyword - ↑ -2147483648 can be stored in two's-complement machines (i.e. most machines in existence). Very old compilers may not recognize the
signed
keyword - ↑ -9223372036854775808 can be stored in two's-complement machines (i.e. most machines in existence)
- ↑ The precedences in a declaration are:
[]
,()
(left associative) — Highest*
(right associative) — Lowest - ↑ The standards do NOT place any restriction on the size/type of the integer, it's implementation dependent. The only mention in the standards is a reference that an implementation may have limits to the maximum size of memory block which can be allocated, and as such the limit on integer will be size_of_max_block/sizeof(type)