C (programming language)

From Wikipedia for FEVERv2
Jump to navigation Jump to search

"C Programming Language" redirects here. C (programming language)_sentence_0

For the book, see The C Programming Language. C (programming language)_sentence_1

C (programming language)_table_infobox_0

CC (programming language)_table_caption_0
ParadigmC (programming language)_header_cell_0_0_0 Imperative (procedural), structuredC (programming language)_cell_0_0_1
Designed byC (programming language)_header_cell_0_1_0 Dennis RitchieC (programming language)_cell_0_1_1
DeveloperC (programming language)_header_cell_0_2_0 Dennis Ritchie & Bell Labs (creators); ANSI X3J11 (ANSI C); ISO/IEC JTC1/SC22/WG14 (ISO C)C (programming language)_cell_0_2_1
First appearedC (programming language)_header_cell_0_3_0 1972; 48 years ago (1972)C (programming language)_cell_0_3_1
Stable releaseC (programming language)_header_cell_0_4_0 C17
  / June 2018; 2 years ago (2018-06)C (programming language)_cell_0_4_1
Preview releaseC (programming language)_header_cell_0_5_0 C2x ()
  / December 11, 2020; 2 days ago (2020-12-11)C (programming language)_cell_0_5_1
Typing disciplineC (programming language)_header_cell_0_6_0 Static, weak, manifest, nominalC (programming language)_cell_0_6_1
OSC (programming language)_header_cell_0_7_0 Cross-platformC (programming language)_cell_0_7_1
C (programming language)_header_cell_0_8_0 .c, .hC (programming language)_cell_0_8_1
WebsiteC (programming language)_header_cell_0_9_0 C (programming language)_cell_0_9_1
Major implementationsC (programming language)_header_cell_0_10_0
DialectsC (programming language)_header_cell_0_11_0
Influenced byC (programming language)_header_cell_0_12_0
InfluencedC (programming language)_header_cell_0_13_0

C (/siː/, as in the letter c) is a general-purpose, procedural computer programming language supporting structured programming, lexical variable scope, and recursion, with a static type system. C (programming language)_sentence_2

By design, C provides constructs that map efficiently to typical machine instructions. C (programming language)_sentence_3

It has found lasting use in applications previously coded in assembly language. C (programming language)_sentence_4

Such applications include operating systems and various application software for computer architectures that range from supercomputers to PLCs and embedded systems. C (programming language)_sentence_5

A successor to the programming language B, C was originally developed at Bell Labs by Dennis Ritchie between 1972 and 1973 to construct utilities running on Unix. C (programming language)_sentence_6

It was applied to re-implementing the kernel of the Unix operating system. C (programming language)_sentence_7

During the 1980s, C gradually gained popularity. C (programming language)_sentence_8

It has become one of the most widely used programming languages, with C compilers from various vendors available for the majority of existing computer architectures and operating systems. C (programming language)_sentence_9

C has been standardized by the ANSI since 1989 (ANSI C) and by the International Organization for Standardization (ISO). C (programming language)_sentence_10

As of September 2020, C is the most popular programming language. C (programming language)_sentence_11

C is an imperative procedural language. C (programming language)_sentence_12

It was designed to be compiled to provide low-level access to memory and language constructs that map efficiently to machine instructions, all with minimal runtime support. C (programming language)_sentence_13

Despite its low-level capabilities, the language was designed to encourage cross-platform programming. C (programming language)_sentence_14

A standards-compliant C program written with portability in mind can be compiled for a wide variety of computer platforms and operating systems with few changes to its source code. C (programming language)_sentence_15

Overview C (programming language)_section_0

Like most procedural languages in the ALGOL tradition, C has facilities for structured programming and allows lexical variable scope and recursion. C (programming language)_sentence_16

Its static type system prevents unintended operations. C (programming language)_sentence_17

In C, all executable code is contained within subroutines (also called "functions", though not strictly in the sense of functional programming). C (programming language)_sentence_18

Function parameters are always passed by value. C (programming language)_sentence_19

Pass-by-reference is simulated in C by explicitly passing pointer values. C (programming language)_sentence_20

C program source text is free-format, using the semicolon as a statement terminator and curly braces for grouping blocks of statements. C (programming language)_sentence_21

The C language also exhibits the following characteristics: C (programming language)_sentence_22

C (programming language)_unordered_list_0

  • The language has a small, fixed number of keywords, including a full set of control flow primitives: if/else, for, do/while, while, and switch. User-defined names are not distinguished from keywords by any kind of sigil.C (programming language)_item_0_0
  • It has a large number of arithmetic, bitwise, and logic operators: +, +=, ++, &, ||, etc.C (programming language)_item_0_1
  • More than one assignment may be performed in a single statement.C (programming language)_item_0_2
  • Functions:C (programming language)_item_0_3
    • Function return values can be ignored, when not needed.C (programming language)_item_0_4
    • Function and data pointers permit ad hoc run-time polymorphism.C (programming language)_item_0_5
    • Functions may not be defined within the lexical scope of other functions.C (programming language)_item_0_6
  • Data typing is static, but weakly enforced; all data has a type, but implicit conversions are possible.C (programming language)_item_0_7
  • Declaration syntax mimics usage context. C has no "define" keyword; instead, a statement beginning with the name of a type is taken as a declaration. There is no "function" keyword; instead, a function is indicated by the presence of a parenthesized argument list.C (programming language)_item_0_8
  • User-defined (typedef) and compound types are possible.C (programming language)_item_0_9
    • Heterogeneous aggregate data types (struct) allow related data elements to be accessed and assigned as a unit.C (programming language)_item_0_10
    • Union is a structure with overlapping members; only the last member stored is valid.C (programming language)_item_0_11
    • Array indexing is a secondary notation, defined in terms of pointer arithmetic. Unlike structs, arrays are not first-class objects: they cannot be assigned or compared using single built-in operators. There is no "array" keyword in use or definition; instead, square brackets indicate arrays syntactically, for example month.C (programming language)_item_0_12
    • Enumerated types are possible with the enum keyword. They are freely interconvertible with integers.C (programming language)_item_0_13
    • Strings are not a distinct data type, but are conventionally implemented as null-terminated character arrays.C (programming language)_item_0_14
  • Low-level access to computer memory is possible by converting machine addresses to typed pointers.C (programming language)_item_0_15
  • Procedures (subroutines not returning values) are a special case of function, with an untyped return type void.C (programming language)_item_0_16
  • A preprocessor performs macro definition, source code file inclusion, and conditional compilation.C (programming language)_item_0_17
  • There is a basic form of modularity: files can be compiled separately and linked together, with control over which functions and data objects are visible to other files via static and extern attributes.C (programming language)_item_0_18
  • Complex functionality such as I/O, string manipulation, and mathematical functions are consistently delegated to library routines.C (programming language)_item_0_19

While C does not include certain features found in other languages (such as object orientation and garbage collection), these can be implemented or emulated, often through the use of external libraries (e.g., the GLib Object System or the Boehm garbage collector). C (programming language)_sentence_23

Relations to other languages C (programming language)_section_1

Many later languages have borrowed directly or indirectly from C, including C++, C#, Unix's C shell, D, Go, Java, JavaScript (including transpilers), Julia, Limbo, LPC, Objective-C, Perl, PHP, Python, Ruby, Rust, Swift, Verilog and SystemVerilog (hardware description languages). C (programming language)_sentence_24

These languages have drawn many of their control structures and other basic features from C. Most of them (Python being a dramatic exception) also express highly similar syntax to C, and they tend to combine the recognizable expression and statement syntax of C with underlying type systems, data models, and semantics that can be radically different. C (programming language)_sentence_25

History C (programming language)_section_2

Early developments C (programming language)_section_3

C (programming language)_table_general_1

Timeline of language developmentC (programming language)_table_caption_1
YearC (programming language)_header_cell_1_0_0 C StandardC (programming language)_header_cell_1_0_1
1972C (programming language)_cell_1_1_0 BirthC (programming language)_cell_1_1_1
1978C (programming language)_cell_1_2_0 K&R CC (programming language)_cell_1_2_1
1989/1990C (programming language)_cell_1_3_0 ANSI C and ISO CC (programming language)_cell_1_3_1
1999C (programming language)_cell_1_4_0 C99C (programming language)_cell_1_4_1
2011C (programming language)_cell_1_5_0 C11C (programming language)_cell_1_5_1
2017C (programming language)_cell_1_6_0 C17C (programming language)_cell_1_6_1
TBDC (programming language)_cell_1_7_0 C2xC (programming language)_cell_1_7_1

The origin of C is closely tied to the development of the Unix operating system, originally implemented in assembly language on a PDP-7 by Dennis Ritchie and Ken Thompson, incorporating several ideas from colleagues. C (programming language)_sentence_26

Eventually, they decided to port the operating system to a PDP-11. C (programming language)_sentence_27

The original PDP-11 version of Unix was also developed in assembly language. C (programming language)_sentence_28

Thompson desired a programming language to make utilities for the new platform. C (programming language)_sentence_29

At first, he tried to make a Fortran compiler, but soon gave up the idea. C (programming language)_sentence_30

Instead, he created a cut-down version of the recently developed BCPL systems programming language. C (programming language)_sentence_31

The official description of BCPL was not available at the time, and Thompson modified the syntax to be less wordy, producing the similar but somewhat simpler B. C (programming language)_sentence_32

However, few utilities were ultimately written in B because it was too slow, and B could not take advantage of PDP-11 features such as byte addressability. C (programming language)_sentence_33

In 1972, Ritchie started to improve B, which resulted in creating a new language C. The C compiler and some utilities made with it were included in Version 2 Unix. C (programming language)_sentence_34

At Version 4 Unix, released in November 1973, the Unix kernel was extensively re-implemented in C. By this time, the C language had acquired some powerful features such as struct types. C (programming language)_sentence_35

Preprocessor was introduced around 1973 at the urging of Alan Snyder and also in recognition of the usefulness of the file-inclusion mechanisms available in BCPL and PL/I. C (programming language)_sentence_36

Its original version provided only included files and simple string replacements: #include and #define of parameterless macros. C (programming language)_sentence_37

Soon after that, it was extended, mostly by Mike Lesk and then by John Reiser, to incorporate macros with arguments and conditional compilation. C (programming language)_sentence_38

Unix was one of the first operating system kernels implemented in a language other than assembly. C (programming language)_sentence_39

Earlier instances include the Multics system (which was written in PL/I) and Master Control Program (MCP) for the Burroughs B5000 (which was written in ALGOL) in 1961. C (programming language)_sentence_40

In around 1977, Ritchie and Stephen C. Johnson made further changes to the language to facilitate portability of the Unix operating system. C (programming language)_sentence_41

Johnson's Portable C Compiler served as the basis for several implementations of C on new platforms. C (programming language)_sentence_42

K&R C C (programming language)_section_4

In 1978, Brian Kernighan and Dennis Ritchie published the first edition of The C Programming Language. C (programming language)_sentence_43

This book, known to C programmers as K&R, served for many years as an informal specification of the language. C (programming language)_sentence_44

The version of C that it describes is commonly referred to as "K&R C". C (programming language)_sentence_45

The second edition of the book covers the later ANSI C standard, described below. C (programming language)_sentence_46

K&R introduced several language features: C (programming language)_sentence_47

C (programming language)_unordered_list_1

  • Standard I/O libraryC (programming language)_item_1_20
  • long int data typeC (programming language)_item_1_21
  • unsigned int data typeC (programming language)_item_1_22
  • Compound assignment operators of the form =op (such as =-) were changed to the form op= (that is, -=) to remove the semantic ambiguity created by constructs such as i=-10, which had been interpreted as i =- 10 (decrement i by 10) instead of the possibly intended i = -10 (let i be -10).C (programming language)_item_1_23

Even after the publication of the 1989 ANSI standard, for many years K&R C was still considered the "lowest common denominator" to which C programmers restricted themselves when maximum portability was desired, since many older compilers were still in use, and because carefully written K&R C code can be legal Standard C as well. C (programming language)_sentence_48

In early versions of C, only functions that return types other than int must be declared if used before the function definition; functions used without prior declaration were presumed to return type int. C (programming language)_sentence_49

For example: C (programming language)_sentence_50

The int type specifiers which are commented out could be omitted in K&R C, but are required in later standards. C (programming language)_sentence_51

Since K&R function declarations did not include any information about function arguments, function parameter type checks were not performed, although some compilers would issue a warning message if a local function was called with the wrong number of arguments, or if multiple calls to an external function used different numbers or types of arguments. C (programming language)_sentence_52

Separate tools such as Unix's lint utility were developed that (among other things) could check for consistency of function use across multiple source files. C (programming language)_sentence_53

In the years following the publication of K&R C, several features were added to the language, supported by compilers from AT&T (in particular PCC) and some other vendors. C (programming language)_sentence_54

These included: C (programming language)_sentence_55

C (programming language)_unordered_list_2

  • void functions (i.e., functions with no return value)C (programming language)_item_2_24
  • functions returning struct or union types (rather than pointers)C (programming language)_item_2_25
  • assignment for struct data typesC (programming language)_item_2_26
  • enumerated typesC (programming language)_item_2_27

The large number of extensions and lack of agreement on a standard library, together with the language popularity and the fact that not even the Unix compilers precisely implemented the K&R specification, led to the necessity of standardization. C (programming language)_sentence_56

ANSI C and ISO C C (programming language)_section_5

Main article: ANSI C C (programming language)_sentence_57

During the late 1970s and 1980s, versions of C were implemented for a wide variety of mainframe computers, minicomputers, and microcomputers, including the IBM PC, as its popularity began to increase significantly. C (programming language)_sentence_58

In 1983, the American National Standards Institute (ANSI) formed a committee, X3J11, to establish a standard specification of C. X3J11 based the C standard on the Unix implementation; however, the non-portable portion of the Unix C library was handed off to the IEEE working group 1003 to become the basis for the 1988 POSIX standard. C (programming language)_sentence_59

In 1989, the C standard was ratified as ANSI X3.159-1989 "Programming Language C". C (programming language)_sentence_60

This version of the language is often referred to as ANSI C, Standard C, or sometimes C89. C (programming language)_sentence_61

In 1990, the ANSI C standard (with formatting changes) was adopted by the International Organization for Standardization (ISO) as ISO/IEC 9899:1990, which is sometimes called C90. C (programming language)_sentence_62

Therefore, the terms "C89" and "C90" refer to the same programming language. C (programming language)_sentence_63

ANSI, like other national standards bodies, no longer develops the C standard independently, but defers to the international C standard, maintained by the working group ISO/IEC JTC1/SC22/WG14. C (programming language)_sentence_64

National adoption of an update to the international standard typically occurs within a year of ISO publication. C (programming language)_sentence_65

One of the aims of the C standardization process was to produce a superset of K&R C, incorporating many of the subsequently introduced unofficial features. C (programming language)_sentence_66

The standards committee also included several additional features such as function prototypes (borrowed from C++), void pointers, support for international character sets and locales, and preprocessor enhancements. C (programming language)_sentence_67

Although the syntax for parameter declarations was augmented to include the style used in C++, the K&R interface continued to be permitted, for compatibility with existing source code. C (programming language)_sentence_68

C89 is supported by current C compilers, and most modern C code is based on it. C (programming language)_sentence_69

Any program written only in Standard C and without any hardware-dependent assumptions will run correctly on any platform with a conforming C implementation, within its resource limits. C (programming language)_sentence_70

Without such precautions, programs may compile only on a certain platform or with a particular compiler, due, for example, to the use of non-standard libraries, such as GUI libraries, or to a reliance on compiler- or platform-specific attributes such as the exact size of data types and byte endianness. C (programming language)_sentence_71

In cases where code must be compilable by either standard-conforming or K&R C-based compilers, the __STDC__ macro can be used to split the code into Standard and K&R sections to prevent the use on a K&R C-based compiler of features available only in Standard C. C (programming language)_sentence_72

After the ANSI/ISO standardization process, the C language specification remained relatively static for several years. C (programming language)_sentence_73

In 1995, Normative Amendment 1 to the 1990 C standard (ISO/IEC 9899/AMD1:1995, known informally as C95) was published, to correct some details and to add more extensive support for international character sets. C (programming language)_sentence_74

C99 C (programming language)_section_6

Main article: C99 C (programming language)_sentence_75

The C standard was further revised in the late 1990s, leading to the publication of ISO/IEC 9899:1999 in 1999, which is commonly referred to as "C99". C (programming language)_sentence_76

It has since been amended three times by Technical Corrigenda. C (programming language)_sentence_77

C99 introduced several new features, including inline functions, several new data types (including long long int and a complex type to represent complex numbers), variable-length arrays and flexible array members, improved support for IEEE 754 floating point, support for variadic macros (macros of variable arity), and support for one-line comments beginning with //, as in BCPL or C++. C (programming language)_sentence_78

Many of these had already been implemented as extensions in several C compilers. C (programming language)_sentence_79

C99 is for the most part backward compatible with C90, but is stricter in some ways; in particular, a declaration that lacks a type specifier no longer has int implicitly assumed. C (programming language)_sentence_80

A standard macro __STDC_VERSION__ is defined with value 199901L to indicate that C99 support is available. C (programming language)_sentence_81

GCC, Solaris Studio, and other C compilers now support many or all of the new features of C99. C (programming language)_sentence_82

The C compiler in Microsoft Visual C++, however, implements the C89 standard and those parts of C99 that are required for compatibility with C++11. C (programming language)_sentence_83

In addition, support for Unicode identifiers (variable / function names) in the form of escaped characters (e.g. \U0001f431) is now required. C (programming language)_sentence_84

Support for raw Unicode names like 🐱 is optional. C (programming language)_sentence_85

C11 C (programming language)_section_7

Main article: C11 (C standard revision) C (programming language)_sentence_86

In 2007, work began on another revision of the C standard, informally called "C1X" until its official publication on 2011-12-08. C (programming language)_sentence_87

The C standards committee adopted guidelines to limit the adoption of new features that had not been tested by existing implementations. C (programming language)_sentence_88

The C11 standard adds numerous new features to C and the library, including type generic macros, anonymous structures, improved Unicode support, atomic operations, multi-threading, and bounds-checked functions. C (programming language)_sentence_89

It also makes some portions of the existing C99 library optional, and improves compatibility with C++. C (programming language)_sentence_90

The standard macro __STDC_VERSION__ is defined as 201112L to indicate that C11 support is available. C (programming language)_sentence_91

C17 C (programming language)_section_8

Main article: C17 (C standard revision) C (programming language)_sentence_92

Published in June 2018, C17 is the current standard for the C programming language. C (programming language)_sentence_93

It introduces no new language features, only technical corrections, and clarifications to defects in C11. C (programming language)_sentence_94

The standard macro __STDC_VERSION__ is defined as 201710L. C (programming language)_sentence_95

C2x C (programming language)_section_9

Main article: C2x C (programming language)_sentence_96

C2x is an informal name for the next (after C17) major C language standard revision. C (programming language)_sentence_97

It is not expected to be voted on until 2021. C (programming language)_sentence_98

Embedded C C (programming language)_section_10

Main article: Embedded C C (programming language)_sentence_99

Historically, embedded C programming requires nonstandard extensions to the C language in order to support exotic features such as fixed-point arithmetic, multiple distinct memory banks, and basic I/O operations. C (programming language)_sentence_100

In 2008, the C Standards Committee published a technical report extending the C language to address these issues by providing a common standard for all implementations to adhere to. C (programming language)_sentence_101

It includes a number of features not available in normal C, such as fixed-point arithmetic, named address spaces, and basic I/O hardware addressing. C (programming language)_sentence_102

Syntax C (programming language)_section_11

Main article: C syntax C (programming language)_sentence_103

C has a formal grammar specified by the C standard. C (programming language)_sentence_104

Line endings are generally not significant in C; however, line boundaries do have significance during the preprocessing phase. C (programming language)_sentence_105

Comments may appear either between the delimiters /* and */, or (since C99) following // until the end of the line. C (programming language)_sentence_106

Comments delimited by /* and */ do not nest, and these sequences of characters are not interpreted as comment delimiters if they appear inside string or character literals. C (programming language)_sentence_107

C source files contain declarations and function definitions. C (programming language)_sentence_108

Function definitions, in turn, contain declarations and statements. C (programming language)_sentence_109

Declarations either define new types using keywords such as struct, union, and enum, or assign types to and perhaps reserve storage for new variables, usually by writing the type followed by the variable name. C (programming language)_sentence_110

Keywords such as char and int specify built-in types. C (programming language)_sentence_111

Sections of code are enclosed in braces ({ and }, sometimes called "curly brackets") to limit the scope of declarations and to act as a single statement for control structures. C (programming language)_sentence_112

As an imperative language, C uses statements to specify actions. C (programming language)_sentence_113

The most common statement is an expression statement, consisting of an expression to be evaluated, followed by a semicolon; as a side effect of the evaluation, functions may be called and variables may be assigned new values. C (programming language)_sentence_114

To modify the normal sequential execution of statements, C provides several control-flow statements identified by reserved keywords. C (programming language)_sentence_115

Structured programming is supported by if(-else) conditional execution and by do-while, while, and for iterative execution (looping). C (programming language)_sentence_116

The for statement has separate initialization, testing, and reinitialization expressions, any or all of which can be omitted. C (programming language)_sentence_117

break and continue can be used to leave the innermost enclosing loop statement or skip to its reinitialization. C (programming language)_sentence_118

There is also a non-structured goto statement which branches directly to the designated label within the function. C (programming language)_sentence_119

switch selects a case to be executed based on the value of an integer expression. C (programming language)_sentence_120

Expressions can use a variety of built-in operators and may contain function calls. C (programming language)_sentence_121

The order in which arguments to functions and operands to most operators are evaluated is unspecified. C (programming language)_sentence_122

The evaluations may even be interleaved. C (programming language)_sentence_123

However, all side effects (including storage to variables) will occur before the next "sequence point"; sequence points include the end of each expression statement, and the entry to and return from each function call. C (programming language)_sentence_124

Sequence points also occur during evaluation of expressions containing certain operators (&&, ||, ? C (programming language)_sentence_125 : and the comma operator). C (programming language)_sentence_126

This permits a high degree of object code optimization by the compiler, but requires C programmers to take more care to obtain reliable results than is needed for other programming languages. C (programming language)_sentence_127

Kernighan and Ritchie say in the Introduction of The C Programming Language: "C, like any other language, has its blemishes. C (programming language)_sentence_128

Some of the operators have the wrong precedence; some parts of the syntax could be better." C (programming language)_sentence_129

The C standard did not attempt to correct many of these blemishes, because of the impact of such changes on already existing software. C (programming language)_sentence_130

Character set C (programming language)_section_12

The basic C source character set includes the following characters: C (programming language)_sentence_131

C (programming language)_unordered_list_3

  • Lowercase and uppercase letters of ISO Basic Latin Alphabet: a–z A–ZC (programming language)_item_3_28
  • Decimal digits: 0–9C (programming language)_item_3_29
  • Graphic characters: ! " # % & ' ( ) * + , - . / : ; < = > ? [ \ ] ^ _ { | } ~C (programming language)_item_3_30
  • Whitespace characters: space, horizontal tab, vertical tab, form feed, newlineC (programming language)_item_3_31

Newline indicates the end of a text line; it need not correspond to an actual single character, although for convenience C treats it as one. C (programming language)_sentence_132

Additional multi-byte encoded characters may be used in string literals, but they are not entirely portable. C (programming language)_sentence_133

The latest C standard (C11) allows multi-national Unicode characters to be embedded portably within C source text by using \uXXXX or \UXXXXXXXX encoding (where the X denotes a hexadecimal character), although this feature is not yet widely implemented. C (programming language)_sentence_134

The basic C execution character set contains the same characters, along with representations for alert, backspace, and carriage return. C (programming language)_sentence_135

Run-time support for extended character sets has increased with each revision of the C standard. C (programming language)_sentence_136

Reserved words C (programming language)_section_13

C89 has 32 reserved words, also known as keywords, which are the words that cannot be used for any purposes other than those for which they are predefined: C (programming language)_sentence_137

C99 reserved five more words: C (programming language)_sentence_138

C11 reserved seven more words: C (programming language)_sentence_139

Most of the recently reserved words begin with an underscore followed by a capital letter, because identifiers of that form were previously reserved by the C standard for use only by implementations. C (programming language)_sentence_140

Since existing program source code should not have been using these identifiers, it would not be affected when C implementations started supporting these extensions to the programming language. C (programming language)_sentence_141

Some standard headers do define more convenient synonyms for underscored identifiers. C (programming language)_sentence_142

The language previously included a reserved word called entry, but this was seldom implemented, and has now been removed as a reserved word. C (programming language)_sentence_143

Operators C (programming language)_section_14

Main article: Operators in C and C++ C (programming language)_sentence_144

C supports a rich set of operators, which are symbols used within an expression to specify the manipulations to be performed while evaluating that expression. C (programming language)_sentence_145

C has operators for: C (programming language)_sentence_146

C (programming language)_unordered_list_4

C uses the operator = (used in mathematics to express equality) to indicate assignment, following the precedent of Fortran and PL/I, but unlike ALGOL and its derivatives. C (programming language)_sentence_147

C uses the operator == to test for equality. C (programming language)_sentence_148

The similarity between these two operators (assignment and equality) may result in the accidental use of one in place of the other, and in many cases, the mistake does not produce an error message (although some compilers produce warnings). C (programming language)_sentence_149

For example, the conditional expression if (a == b + 1) might mistakenly be written as if (a = b + 1), which will be evaluated as true if a is not zero after the assignment. C (programming language)_sentence_150

The C operator precedence is not always intuitive. C (programming language)_sentence_151

For example, the operator == binds more tightly than (is executed prior to) the operators & (bitwise AND) and | (bitwise OR) in expressions such as x & 1 == 0, which must be written as (x & 1) == 0 if that is the coder's intent. C (programming language)_sentence_152

"Hello, world" example C (programming language)_section_15

See also: Hello, world C (programming language)_sentence_153

The "hello, world" example, which appeared in the first edition of K&R, has become the model for an introductory program in most programming textbooks. C (programming language)_sentence_154

The program prints "hello, world" to the standard output, which is usually a terminal or screen display. C (programming language)_sentence_155

The original version was: C (programming language)_sentence_156

A standard-conforming "hello, world" program is: C (programming language)_sentence_157

The first line of the program contains a preprocessing directive, indicated by #include. C (programming language)_sentence_158

This causes the compiler to replace that line with the entire text of the stdio.h standard header, which contains declarations for standard input and output functions such as printf and scanf. C (programming language)_sentence_159

The angle brackets surrounding stdio.h indicate that stdio.h is located using a search strategy that prefers headers provided with the compiler to other headers having the same name, as opposed to double quotes which typically include local or project-specific header files. C (programming language)_sentence_160

The next line indicates that a function named main is being defined. C (programming language)_sentence_161

The main function serves a special purpose in C programs; the run-time environment calls the main function to begin program execution. C (programming language)_sentence_162

The type specifier int indicates that the value that is returned to the invoker (in this case the run-time environment) as a result of evaluating the main function, is an integer. C (programming language)_sentence_163

The keyword void as a parameter list indicates that this function takes no arguments. C (programming language)_sentence_164

The opening curly brace indicates the beginning of the definition of the main function. C (programming language)_sentence_165

The next line calls (diverts execution to) a function named printf, which in this case is supplied from a system library. C (programming language)_sentence_166

In this call, the printf function is passed (provided with) a single argument, the address of the first character in the string literal "hello, world\n". C (programming language)_sentence_167

The string literal is an unnamed array with elements of type char, set up automatically by the compiler with a final 0-valued character to mark the end of the array (printf needs to know this). C (programming language)_sentence_168

The \n is an escape sequence that C translates to a newline character, which on output signifies the end of the current line. C (programming language)_sentence_169

The return value of the printf function is of type int, but it is silently discarded since it is not used. C (programming language)_sentence_170

(A more careful program might test the return value to determine whether or not the printf function succeeded.) C (programming language)_sentence_171

The semicolon ; terminates the statement. C (programming language)_sentence_172

The closing curly brace indicates the end of the code for the main function. C (programming language)_sentence_173

According to the C99 specification and newer, the main function, unlike any other function, will implicitly return a value of 0 upon reaching the } that terminates the function. C (programming language)_sentence_174

(Formerly an explicit return 0; statement was required.) C (programming language)_sentence_175

This is interpreted by the run-time system as an exit code indicating successful execution. C (programming language)_sentence_176

Data types C (programming language)_section_16

Main article: C variable types and declarations C (programming language)_sentence_177

Memory management C (programming language)_section_17

One of the most important functions of a programming language is to provide facilities for managing memory and the objects that are stored in memory. C (programming language)_sentence_178

C provides three distinct ways to allocate memory for objects: C (programming language)_sentence_179

C (programming language)_unordered_list_5

  • Static memory allocation: space for the object is provided in the binary at compile-time; these objects have an extent (or lifetime) as long as the binary which contains them is loaded into memory.C (programming language)_item_5_49
  • Automatic memory allocation: temporary objects can be stored on the stack, and this space is automatically freed and reusable after the block in which they are declared is exited.C (programming language)_item_5_50
  • Dynamic memory allocation: blocks of memory of arbitrary size can be requested at run-time using library functions such as malloc from a region of memory called the heap; these blocks persist until subsequently freed for reuse by calling the library function realloc or freeC (programming language)_item_5_51

These three approaches are appropriate in different situations and have various trade-offs. C (programming language)_sentence_180

For example, static memory allocation has little allocation overhead, automatic allocation may involve slightly more overhead, and dynamic memory allocation can potentially have a great deal of overhead for both allocation and deallocation. C (programming language)_sentence_181

The persistent nature of static objects is useful for maintaining state information across function calls, automatic allocation is easy to use but stack space is typically much more limited and transient than either static memory or heap space, and dynamic memory allocation allows convenient allocation of objects whose size is known only at run-time. C (programming language)_sentence_182

Most C programs make extensive use of all three. C (programming language)_sentence_183

Where possible, automatic or static allocation is usually simplest because the storage is managed by the compiler, freeing the programmer of the potentially error-prone chore of manually allocating and releasing storage. C (programming language)_sentence_184

However, many data structures can change in size at runtime, and since static allocations (and automatic allocations before C99) must have a fixed size at compile-time, there are many situations in which dynamic allocation is necessary. C (programming language)_sentence_185

Prior to the C99 standard, variable-sized arrays were a common example of this. C (programming language)_sentence_186

(See the article on malloc for an example of dynamically allocated arrays.) C (programming language)_sentence_187

Unlike automatic allocation, which can fail at run time with uncontrolled consequences, the dynamic allocation functions return an indication (in the form of a null pointer value) when the required storage cannot be allocated. C (programming language)_sentence_188

(Static allocation that is too large is usually detected by the linker or loader, before the program can even begin execution.) C (programming language)_sentence_189

Unless otherwise specified, static objects contain zero or null pointer values upon program startup. C (programming language)_sentence_190

Automatically and dynamically allocated objects are initialized only if an initial value is explicitly specified; otherwise they initially have indeterminate values (typically, whatever bit pattern happens to be present in the storage, which might not even represent a valid value for that type). C (programming language)_sentence_191

If the program attempts to access an uninitialized value, the results are undefined. C (programming language)_sentence_192

Many modern compilers try to detect and warn about this problem, but both false positives and false negatives can occur. C (programming language)_sentence_193

Another issue is that heap memory allocation has to be synchronized with its actual usage in any program in order for it to be reused as much as possible. C (programming language)_sentence_194

For example, if the only pointer to a heap memory allocation goes out of scope or has its value overwritten before free() is called, then that memory cannot be recovered for later reuse and is essentially lost to the program, a phenomenon known as a memory leak. C (programming language)_sentence_195

Conversely, it is possible for memory to be freed but continue to be referenced, leading to unpredictable results. C (programming language)_sentence_196

Typically, the symptoms will appear in a portion of the program far removed from the actual error, making it difficult to track down the problem. C (programming language)_sentence_197

(Such issues are ameliorated in languages with automatic garbage collection.) C (programming language)_sentence_198

Libraries C (programming language)_section_18

The C programming language uses libraries as its primary method of extension. C (programming language)_sentence_199

In C, a library is a set of functions contained within a single "archive" file. C (programming language)_sentence_200

Each library typically has a , which contains the prototypes of the functions contained within the library that may be used by a program, and declarations of special data types and macro symbols used with these functions. C (programming language)_sentence_201

In order for a program to use a library, it must include the library's header file, and the library must be linked with the program, which in many cases requires compiler flags (e.g., -lm, shorthand for "link the math library"). C (programming language)_sentence_202

The most common C library is the C standard library, which is specified by the ISO and ANSI C standards and comes with every C implementation (implementations which target limited environments such as embedded systems may provide only a subset of the standard library). C (programming language)_sentence_203

This library supports stream input and output, memory allocation, mathematics, character strings, and time values. C (programming language)_sentence_204

Several separate standard headers (for example, stdio.h) specify the interfaces for these and other standard library facilities. C (programming language)_sentence_205

Another common set of C library functions are those used by applications specifically targeted for Unix and Unix-like systems, especially functions which provide an interface to the kernel. C (programming language)_sentence_206

These functions are detailed in various standards such as POSIX and the Single UNIX Specification. C (programming language)_sentence_207

Since many programs have been written in C, there are a wide variety of other libraries available. C (programming language)_sentence_208

Libraries are often written in C because C compilers generate efficient object code; programmers then create interfaces to the library so that the routines can be used from higher-level languages like Java, Perl, and Python. C (programming language)_sentence_209

File handling and streams C (programming language)_section_19

File input and output (I/O) is not part of the C language itself but instead is handled by libraries (such as the C standard library) and their associated header files (e.g. stdio.h). C (programming language)_sentence_210

File handling is generally implemented through high-level I/O which works through streams. C (programming language)_sentence_211

A stream is from this perspective a data flow that is independent of devices, while a file is a concrete device. C (programming language)_sentence_212

The high level I/O is done through the association of a stream to a file. C (programming language)_sentence_213

In the C standard library, a buffer (a memory area or queue) is temporarily used to store data before it's sent to the final destination. C (programming language)_sentence_214

This reduces the time spent waiting for slower devices, for example a hard drive or solid state drive. C (programming language)_sentence_215

Low-level I/O functions are not part of the standard C library but are generally part of "bare metal" programming (programming that's independent of any operating system such as most but not all embedded programming). C (programming language)_sentence_216

With few exceptions, implementations include low-level I/O. C (programming language)_sentence_217

Language tools C (programming language)_section_20

Uses C (programming language)_section_21

C is widely used for systems programming in implementing operating systems and embedded system applications, because C code, when written for portability, can be used for most purposes, yet when needed, system-specific code can be used to access specific hardware addresses and to perform type punning to match externally imposed interface requirements, with a low run-time demand on system resources. C (programming language)_sentence_218

C can be used for website programming using the Common Gateway Interface (CGI) as a "gateway" for information between the Web application, the server, and the browser. C (programming language)_sentence_219

C is often chosen over interpreted languages because of its speed, stability, and near-universal availability. C (programming language)_sentence_220

A consequence of C's wide availability and efficiency is that compilers, libraries and interpreters of other programming languages are often implemented in C. For example, the reference implementations of Python, Perl, and PHP are written in C. C (programming language)_sentence_221

C enables programmers to create efficient implementations of algorithms and data structures, because the layer of abstraction from hardware is thin, and its overhead is low, an important criterion for computationally intensive programs. C (programming language)_sentence_222

For example, the GNU Multiple Precision Arithmetic Library, the GNU Scientific Library, Mathematica, and MATLAB are completely or partially written in C. C (programming language)_sentence_223

C is sometimes used as an intermediate language by implementations of other languages. C (programming language)_sentence_224

This approach may be used for portability or convenience; by using C as an intermediate language, additional machine-specific code generators are not necessary. C (programming language)_sentence_225

C has some features, such as line-number preprocessor directives and optional superfluous commas at the end of initializer lists, that support compilation of generated code. C (programming language)_sentence_226

However, some of C's shortcomings have prompted the development of other C-based languages specifically designed for use as intermediate languages, such as C--. C (programming language)_sentence_227

C has also been widely used to implement end-user applications. C (programming language)_sentence_228

However, such applications can also be written in newer, higher-level languages. C (programming language)_sentence_229

Related languages C (programming language)_section_22

C has both directly and indirectly influenced many later languages such as C#, D, Go, Java, JavaScript, Limbo, LPC, Perl, PHP, Python, and Unix's C shell. C (programming language)_sentence_230

The most pervasive influence has been syntactical; all of the languages mentioned combine the statement and (more or less recognizably) expression syntax of C with type systems, data models, and/or large-scale program structures that differ from those of C, sometimes radically. C (programming language)_sentence_231

Several C or near-C interpreters exist, including Ch and CINT, which can also be used for scripting. C (programming language)_sentence_232

When object-oriented languages became popular, C++ and Objective-C were two different extensions of C that provided object-oriented capabilities. C (programming language)_sentence_233

Both languages were originally implemented as source-to-source compilers; source code was translated into C, and then compiled with a C compiler. C (programming language)_sentence_234

The C++ programming language was devised by Bjarne Stroustrup as an approach to providing object-oriented functionality with a C-like syntax. C (programming language)_sentence_235

C++ adds greater typing strength, scoping, and other tools useful in object-oriented programming, and permits generic programming via templates. C (programming language)_sentence_236

Nearly a superset of C, C++ now supports most of C, with a few exceptions. C (programming language)_sentence_237

Objective-C was originally a very "thin" layer on top of C, and remains a strict superset of C that permits object-oriented programming using a hybrid dynamic/static typing paradigm. C (programming language)_sentence_238

Objective-C derives its syntax from both C and Smalltalk: syntax that involves preprocessing, expressions, function declarations, and function calls is inherited from C, while the syntax for object-oriented features was originally taken from Smalltalk. C (programming language)_sentence_239

In addition to C++ and Objective-C, Ch, Cilk, and Unified Parallel C are nearly supersets of C. C (programming language)_sentence_240

See also C (programming language)_section_23

C (programming language)_unordered_list_6


Credits to the contents of this page go to the authors of the corresponding Wikipedia page: en.wikipedia.org/wiki/C (programming language).