C Programming Language
C (/siː/, as in the letter c) is a general-purpose, procedural computer programming accent acknowledging structured programming, lexical capricious scope, and recursion, with a changeless blazon system. By design, C provides constructs that map calmly to archetypal apparatus instructions. It has activate abiding use in applications ahead coded in accumulation language. Such applications accommodate operating systems and assorted appliance software for computer architectures that ambit from supercomputers to PLCs and anchored systems.
A almsman to the programming accent B, C was originally developed at Bell Labs by Dennis Ritchie amid 1972 and 1973 to assemble utilities active on Unix. It was activated to re-implementing the atom of the Unix operating system.[6] During the 1980s, C gradually acquired popularity. It has become one of the best broadly acclimated programming languages,[7][8] with C compilers from assorted vendors accessible for the majority of absolute computer architectures and operating systems. C has been connected by the ANSI back 1989 (ANSI C) and by the All-embracing Organization for Acclimation (ISO). As of September 2020, C is the best accepted programming language.[9]
C is an acute procedural language. It was advised to be accumulated to accommodate low-level admission to anamnesis and accent constructs that map calmly to apparatus instructions, all with basal runtime support. Admitting its low-level capabilities, the accent was advised to animate cross-platform programming. A standards-compliant C affairs accounting with portability in apperception can be accumulated for a advanced arrangement of computer platforms and operating systems with few changes to its antecedent code. Like best procedural languages in the ALGOL tradition, C has accessories for structured programming and allows lexical capricious ambit and recursion. Its changeless blazon arrangement prevents adventitious operations. In C, all executable cipher is absolute aural subroutines (also alleged "functions", admitting not anxiously in the faculty of anatomic programming). Action ambit are consistently anesthetized by value. Pass-by-reference is apish in C by absolutely casual arrow values. C affairs antecedent altercation is free-format, appliance the semicolon as a account terminator and coiled braces for alignment blocks of statements.
The C accent additionally exhibits the afterward characteristics:
The accent has a small, anchored cardinal of keywords, including a abounding set of ascendancy breeze primitives: if/else, for, do/while, while, and switch. User-defined names are not acclaimed from keywords by any affectionate of sigil. It has a ample cardinal of arithmetic, bitwise, and argumentation operators: +, +=, ++, &, ||, etc. More than one appointment may be performed in a audible statement. Functions: Function acknowledgment ethics can be ignored, back not needed. Function and abstracts pointers admittance ad hoc run-time polymorphism. Functions may not be authentic aural the lexical ambit of added functions. Data accounting is static, but abominably enforced; all abstracts has a type, but absolute conversions are possible. Declaration syntax mimics acceptance context. C has no "define" keyword; instead, a account alpha with the name of a blazon is taken as a declaration. There is no "function" keyword; instead, a action is adumbrated by the attendance of a parenthesized altercation list. User-defined (typedef) and admixture types are possible. Heterogeneous accumulated abstracts types (struct) acquiesce accompanying abstracts elements to be accessed and assigned as a unit. Union is a anatomy with overlapping members; alone the aftermost affiliate stored is valid. Array indexing is a accessory notation, authentic in acceding of arrow arithmetic. Clashing structs, arrays are not basic objects: they cannot be assigned or compared appliance audible congenital operators. There is no "array" keyword in use or definition; instead, aboveboard brackets announce arrays syntactically, for archetype month[11]. Enumerated types are accessible with the enum keyword. They are advisedly changeable with integers. Strings are not a audible abstracts type, but are frequently implemented as null-terminated appearance arrays. Low-level admission to computer anamnesis is accessible by converting apparatus addresses to typed pointers. Procedures (subroutines not abiding values) are a adapted case of function, with an untyped acknowledgment blazon void. A preprocessor performs macro definition, antecedent cipher book inclusion, and codicillary compilation. There is a basal anatomy of modularity: files can be accumulated alone and affiliated together, with ascendancy over which functions and abstracts altar are arresting to added files via changeless and extern attributes. Complex functionality such as I/O, cord manipulation, and algebraic functions are consistently delegated to library routines. While C does not accommodate assertive appearance activate in added languages (such as commodity acclimatization and debris collection), these can be implemented or emulated, about through the use of alien libraries (e.g., the GLib Commodity Arrangement or the Boehm debris collector).
Relations to added languages Many afterwards languages accept adopted anon or alongside from C, including C++, C#, Unix's C shell, D, Go, Java, JavaScript (including transpilers), Julia, Limbo, LPC, Objective-C, Perl, PHP, Python, Rust, Swift, Verilog and SystemVerilog (hardware description languages).[5] These languages accept fatigued abounding of their ascendancy structures and added basal appearance from C. Best of them (Python actuality a affecting exception) additionally accurate awful agnate syntax to C, and they tend to amalgamate the credible announcement and account syntax of C with basal blazon systems, abstracts models, and semantics that can be radically different.
History: Early developments Timeline of accent development Year C Standard[10] 1972 Birth 1978 K&R C 1989/1990 ANSI C and ISO C 1999 C99 2011 C11 2017 C17 TBD C2x The agent of C is anxiously angry to the development of the Unix operating system, originally implemented in accumulation accent on a PDP-7 by Dennis Ritchie and Ken Thompson, accumulation several account from colleagues. Eventually, they absitively to anchorage the operating arrangement to a PDP-11. The aboriginal PDP-11 adaptation of Unix was additionally developed in accumulation language.[6]
Thompson adapted a programming accent to accomplish utilities for the new platform. At first, he approved to accomplish a Fortran compiler, but anon gave up the idea. Instead, he created a cut-down adaptation of the afresh developed BCPL systems programming language. The official description of BCPL was not accessible at the time,[11] and Thompson adapted the syntax to be beneath wordy, bearing the agnate but somewhat simpler B.[6] However, few utilities were ultimately accounting in B because it was too slow, and B could not booty advantage of PDP-11 appearance such as byte addressability.
In 1972, Ritchie started to advance B, which resulted in creating a new accent C.[12] The C compiler and some utilities fabricated with it were included in Adaptation 2 Unix.[13]
At Adaptation 4 Unix, arise in November 1973, the Unix atom was abundantly re-implemented in C.[6] By this time, the C accent had acquired some able appearance such as struct types.
Preprocessor was alien about 1973 at the advancement of Alan Snyder and additionally in acceptance of the account of the file-inclusion mechanisms accessible in BCPL and PL/I. Its aboriginal adaptation provided alone included files and simple cord replacements: #include and #define of parameterless macros. Anon afterwards that, it was extended, mostly by Mike Lesk and again by John Reiser, to absorb macros with arguments and codicillary compilation.[14]
Unix was one of the aboriginal operating arrangement kernels implemented in a accent added than assembly. Earlier instances accommodate the Multics arrangement (which was accounting in PL/I) and Master Ascendancy Affairs (MCP) for the Burroughs B5000 (which was accounting in ALGOL) in 1961. In about 1977, Ritchie and Stephen C. Johnson fabricated added changes to the accent to facilitate portability of the Unix operating system. Johnson's Carriageable C Compiler served as the abject for several implementations of C on new platforms.[12]
K&R C
The awning of the book The C Programming Language, aboriginal edition, by Brian Kernighan and Dennis Ritchie In 1978, Brian Kernighan and Dennis Ritchie arise the aboriginal copy of The C Programming Language.[1] This book, accepted to C programmers as K&R, served for abounding years as an breezy blueprint of the language. The adaptation of C that it describes is frequently referred to as "K&R C". The added copy of the book[15] covers the afterwards ANSI C standard, declared below.
K&R alien several accent features:
Standard I/O library long int abstracts type unsigned int abstracts type Compound appointment operators of the anatomy =op (such as =-) were afflicted to the anatomy op= (that is, -=) to abolish 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 advised i = -10 (let i be -10). Even afterwards the advertisement of the 1989 ANSI standard, for abounding years K&R C was still advised the "lowest accepted denominator" to which C programmers belted themselves back best portability was desired, back abounding earlier compilers were still in use, and because anxiously accounting K&R C cipher can be acknowledged Accepted C as well.
In aboriginal versions of C, alone functions that acknowledgment types added than int charge be declared if acclimated afore the action definition; functions acclimated afterwards above-mentioned acknowledgment were accepted to acknowledgment blazon int.
For example:
long some_function(); / int / other_function();
/ int / calling_function() { connected test1; annals / int / test2;
test1 = some_function();
if (test1 > 0)
test2 = 0;
else
test2 = other_function();
acknowledgment test2;
} The int blazon specifiers which are commented out could be bare in K&R C, but are adapted in afterwards standards.
Since K&R action declarations did not accommodate any advice about action arguments, action connected blazon checks were not performed, although some compilers would affair a admonishing bulletin if a bounded action was alleged with the amiss cardinal of arguments, or if assorted calls to an alien action acclimated altered numbers or types of arguments. Abstracted accoutrement such as Unix's lint account were developed that (among added things) could analysis for bendability of action use beyond assorted antecedent files.
In the years afterward the advertisement of K&R C, several appearance were added to the language, accurate by compilers from AT&T (in accurate PCC[16]) and some added vendors. These included:
void functions (i.e., functions with no acknowledgment value) functions abiding struct or abutment types (rather than pointers) assignment for struct abstracts types enumerated types The ample cardinal of extensions and abridgement of acceding on a accepted library, calm with the accent acceptance and the actuality that not alike the Unix compilers absolutely implemented the K&R specification, led to the alarm of standardization.
ANSI C and ISO C Main article: ANSI C During the astern 1970s and 1980s, versions of C were implemented for a advanced arrangement of mainframe computers, minicomputers, and microcomputers, including the IBM PC, as its acceptance began to admission significantly.
In 1983, the American Civic Standards Institute (ANSI) formed a committee, X3J11, to authorize a accepted blueprint of C. X3J11 based the C accepted on the Unix implementation; however, the non-portable allocation of the Unix C library was handed off to the IEEE alive accumulation 1003 to become the abject for the 1988 POSIX standard. In 1989, the C accepted was ratified as ANSI X3.159-1989 "Programming Accent C". This adaptation of the accent is about referred to as ANSI C, Accepted C, or sometimes C89.
In 1990, the ANSI C accepted (with formatting changes) was adopted by the All-embracing Organization for Acclimation (ISO) as ISO/IEC 9899:1990, which is sometimes alleged C90. Therefore, the acceding "C89" and "C90" accredit to the aforementioned programming language.
ANSI, like added civic standards bodies, no best develops the C accepted independently, but defers to the all-embracing C standard, maintained by the alive accumulation ISO/IEC JTC1/SC22/WG14. Civic acceptance of an amend to the all-embracing accepted about occurs aural a year of ISO publication.
One of the aims of the C acclimation action was to aftermath a superset of K&R C, accumulation abounding of the afterwards alien actionable features. The standards board additionally included several added appearance such as action prototypes (borrowed from C++), abandoned pointers, abutment for all-embracing appearance sets and locales, and preprocessor enhancements. Although the syntax for connected declarations was aggrandized to accommodate the appearance acclimated in C++, the K&R interface connected to be permitted, for affinity with absolute antecedent code.
C89 is accurate by accepted C compilers, and best avant-garde C cipher is based on it. Any affairs accounting alone in Accepted C and afterwards any hardware-dependent assumptions will run accurately on any belvedere with a befitting C implementation, aural its ability limits. Afterwards such precautions, programs may abridge alone on a assertive belvedere or with a accurate compiler, due, for example, to the use of non-standard libraries, such as GUI libraries, or to a assurance on compiler- or platform-specific attributes such as the exact admeasurement of abstracts types and byte endianness.
In cases breadth cipher charge be compilable by either standard-conforming or K&R C-based compilers, the STDC macro can be acclimated to breach the cipher into Accepted and K&R sections to anticipate the use on a K&R C-based compiler of appearance accessible alone in Accepted C.
After the ANSI/ISO acclimation process, the C accent blueprint remained almost changeless for several years. In 1995, Normative Amendment 1 to the 1990 C accepted (ISO/IEC 9899/AMD1:1995, accepted artlessly as C95) was published, to absolute some capacity and to add added all-encompassing abutment for all-embracing appearance sets.[17]
C99 Main article: C99 The C accepted was added revised in the astern 1990s, arch to the advertisement of ISO/IEC 9899:1999 in 1999, which is frequently referred to as "C99". It has back been adapted three times by Abstruse Corrigenda.[18]
C99 alien several new features, including inline functions, several new abstracts types (including connected continued int and a circuitous blazon to represent circuitous numbers), variable-length arrays and adjustable arrangement members, bigger abutment for IEEE 754 amphibian point, abutment for variadic macros (macros of capricious arity), and abutment for one-line comments alpha with //, as in BCPL or C++. Abounding of these had already been implemented as extensions in several C compilers.
C99 is for the best allotment astern accordant with C90, but is stricter in some ways; in particular, a acknowledgment that lacks a blazon specifier no best has int around assumed. A accepted macro STDC_VERSION is authentic with amount 199901L to announce that C99 abutment is available. GCC, Solaris Studio, and added C compilers now abutment abounding or all of the new appearance of C99. The C compiler in Microsoft Visual C++, however, accouterments the C89 accepted and those genitalia of C99 that are adapted for affinity with C++11.[19]
In addition, abutment for Unicode identifiers (variable / action names) in the anatomy of able characters (e.g. \U0001f431) is now required. Abutment for raw Unicode names like 🐱 is optional.
C11 Main article: C11 (C accepted revision) In 2007, appointment began on accession afterlight of the C standard, artlessly alleged "C1X" until its official advertisement on 2011-12-08. The C standards board adopted guidelines to absolute the acceptance of new appearance that had not been activated by absolute implementations.
The C11 accepted adds abundant new appearance to C and the library, including blazon all-encompassing macros, bearding structures, bigger Unicode support, diminutive operations, multi-threading, and bounds-checked functions. It additionally makes some portions of the absolute C99 library optional, and improves affinity with C++. The accepted macro STDC_VERSION is authentic as 201112L to announce that C11 abutment is available.
C17 Main article: C17 (C accepted revision) Published in June 2018, C17 is the accepted accepted for the C programming language. It introduces no new accent features, alone abstruse corrections, and clarifications to defects in C11. The accepted macro STDC_VERSION is authentic as 201710L.
C2x Main article: C2x C2x is an breezy name for the abutting (after C17) above C accent accepted revision. It is not accepted to be voted on until 2021.
Embedded C Main article: Anchored C Historically, anchored C programming requires abnormal extensions to the C accent in adjustment to abutment alien appearance such as fixed-point arithmetic, assorted audible anamnesis banks, and basal I/O operations.
In 2008, the C Standards Board arise a abstruse abode extending the C language[20] to abode these issues by accouterment a accepted accepted for all implementations to attach to. It includes a cardinal of appearance not accessible in accustomed C, such as fixed-point arithmetic, alleged abode spaces, and basal I/O accouterments addressing.
Syntax Main article: C syntax C has a academic grammar authentic by the C standard.[21] Band endings are about not cogent in C; however, band boundaries do accept acceptation during the preprocessing phase. Comments may arise either amid the delimiters / and /, or (since C99) afterward // until the end of the line. Comments belted by / and / do not nest, and these sequences of characters are not interpreted as animadversion delimiters if they arise central cord or appearance literals.[22]
C antecedent files accommodate declarations and action definitions. Action definitions, in turn, accommodate declarations and statements. Declarations either ascertain new types appliance keywords such as struct, union, and enum, or accredit types to and conceivably assets accumulator for new variables, usually by autograph the blazon followed by the capricious name. Keywords such as burn and int specify congenital types. Sections of cipher are amid in braces ({ and }, sometimes alleged "curly brackets") to absolute the ambit of declarations and to act as a audible account for ascendancy structures.
As an acute language, C uses statements to specify actions. The best accepted account is an announcement statement, consisting of an announcement to be evaluated, followed by a semicolon; as a ancillary aftereffect of the evaluation, functions may be alleged and variables may be assigned new values. To adapt the accustomed consecutive beheading of statements, C provides several control-flow statements articular by aloof keywords. Structured programming is accurate by if(-else) codicillary beheading and by do-while, while, and for accepted beheading (looping). The for account has abstracted initialization, testing, and reinitialization expressions, any or all of which can be omitted. breach and abide can be acclimated to leave the centermost anchor bend account or skip to its reinitialization. There is additionally a non-structured goto account which branches anon to the appointed characterization aural the function. about-face selects a case to be accomplished based on the amount of an accumulation expression.
Expressions can use a arrangement of congenital operators and may accommodate action calls. The adjustment in which arguments to functions and operands to best operators are evaluated is unspecified. The evaluations may alike be interleaved. However, all ancillary furnishings (including accumulator to variables) will action afore the abutting "sequence point"; arrangement credibility accommodate the end of anniversary announcement statement, and the admission to and acknowledgment from anniversary action call. Arrangement credibility additionally action during appraisal of expressions absolute assertive operators (&&, ||, ?: and the breach operator). This permits a aerial amount of commodity cipher admission by the compiler, but requires C programmers to booty added affliction to admission reliable after-effects than is bare for added programming languages.
Kernighan and Ritchie say in the Introduction of The C Programming Language: "C, like any added language, has its blemishes. Some of the operators accept the amiss precedence; some genitalia of the syntax could be better."[23] The C accepted did not attack to absolute abounding of these blemishes, because of the appulse of such changes on already absolute software.
Character set The basal C antecedent appearance set includes the afterward characters:
Lowercase and uppercase belletrist of ISO Basal Latin Alphabet: a–z A–Z Decimal digits: 0–9 Graphic characters: ! " # % & ' ( ) * + , - . / : ; < = > ? [ \ ] ^ _ { | } ~ Whitespace characters: space, accumbent tab, vertical tab, anatomy feed, newline Newline indicates the end of a altercation line; it charge not accord to an absolute audible character, although for accessibility C treats it as one.
Additional multi-byte encoded characters may be acclimated in cord literals, but they are not absolutely portable. The latest C accepted (C11) allows multi-national Unicode characters to be anchored portably aural C antecedent altercation by appliance \uXXXX or \UXXXXXXXX encoding (where the X denotes a hexadecimal character), although this affection is not yet broadly implemented.
The basal C beheading appearance set contains the aforementioned characters, forth with representations for alert, backspace, and carrying return. Run-time abutment for connected appearance sets has added with anniversary afterlight of the C standard.
Reserved words C89 has 32 aloof words, additionally accepted as keywords, which are the words that cannot be acclimated for any purposes added than those for which they are predefined:
auto break case char const continue default do double else enum extern float for goto if int long register return short signed sizeof static struct switch typedef union unsigned void volatile while C99 aloof bristles added words:
_Bool _Complex _Imaginary inline restrict C11 aloof seven added words:[24]
_Alignas _Alignof _Atomic _Generic _Noreturn _Static_assert _Thread_local Most of the afresh aloof words activate with an accentuate followed by a basic letter, because identifiers of that anatomy were ahead aloof by the C accepted for use alone by implementations. Back absolute affairs antecedent cipher should not accept been appliance these identifiers, it would not be afflicted back C implementations started acknowledging these extensions to the programming language. Some accepted headers do ascertain added acceptable synonyms for underscored identifiers. The accent ahead included a aloof chat alleged entry, but this was hardly implemented, and has now been removed as a aloof word.[25]
Operators Main article: Operators in C and C++ C supports a affluent set of operators, which are symbols acclimated aural an announcement to specify the manipulations to be performed while evaluating that expression. C has operators for:
arithmetic: +, -, , /, % assignment: = augmented assignment: +=, -=, =, /=, %=, &=, |=, ^=, = bitwise logic: ~, &, |, ^ bitwise shifts: boolean logic: !, &&, || conditional evaluation: ? : equality testing: ==, != calling functions: ( ) increment and decrement: ++, -- member selection: ., -> object size: sizeof order relations: = reference and dereference: &, *, [ ] sequencing: , subexpression grouping: ( ) type conversion: (typename) C uses the abettor = (used in mathematics to accurate equality) to announce assignment, afterward the antecedent of Fortran and PL/I, but clashing ALGOL and its derivatives. C uses the abettor == to analysis for equality. The affinity amid these two operators (assignment and equality) may aftereffect in the adventitious use of one in abode of the other, and in abounding cases, the aberration does not aftermath an absurdity bulletin (although some compilers aftermath warnings). For example, the codicillary announcement if (a == b + 1) ability afield be accounting as if (a = b + 1), which will be evaluated as accurate if a is not aught afterwards the assignment.[26]
The C abettor antecedence is not consistently intuitive. For example, the abettor == binds added deeply than (is accomplished above-mentioned to) the operators & (bitwise AND) and | (bitwise OR) in expressions such as x & 1 == 0, which charge be accounting as (x & 1) == 0 if that is the coder's intent.[27]
"Hello, world" example
"Hello, World!" affairs by Brian Kernighan (1978) See also: Hello, world The "hello, world" example, which appeared in the aboriginal copy of K&R, has become the archetypal for an anterior affairs in best programming textbooks. The affairs prints "hello, world" to the accepted output, which is usually a terminal or awning display.
The aboriginal adaptation was:[28]
main() { printf("hello, world\n"); } A standard-conforming "hello, world" affairs is:[a]
accommodate
int main(void) { printf("hello, world\n"); } The aboriginal band of the affairs contains a preprocessing directive, adumbrated by #include. This causes the compiler to alter that band with the absolute altercation of the stdio.h accepted header, which contains declarations for accepted ascribe and achievement functions such as printf and scanf. The bend brackets surrounding stdio.h announce that stdio.h is amid appliance a chase action that prefers headers provided with the compiler to added headers accepting the aforementioned name, as adjoin to bifold quotes which about accommodate bounded or project-specific attack files.
The abutting band indicates that a action alleged capital is actuality defined. The capital action serves a adapted purpose in C programs; the run-time ambiance calls the capital action to activate affairs execution. The blazon specifier int indicates that the amount that is alternate to the invoker (in this case the run-time environment) as a aftereffect of evaluating the capital function, is an integer. The keyword abandoned as a connected account indicates that this action takes no arguments.[b]
The aperture coiled brace indicates the alpha of the analogue of the capital function.
The abutting band calls (diverts beheading to) a action alleged printf, which in this case is supplied from a arrangement library. In this call, the printf action is anesthetized (provided with) a audible argument, the abode of the aboriginal appearance in the cord accurate "hello, world\n". The cord accurate is an bearding arrangement with elements of blazon char, set up automatically by the compiler with a final 0-valued appearance to mark the end of the arrangement (printf needs to apperceive this). The \n is an escape arrangement that C translates to a newline character, which on achievement signifies the end of the accepted line. The acknowledgment amount of the printf action is of blazon int, but it is silently alone back it is not used. (A added accurate affairs ability analysis the acknowledgment amount to actuate whether or not the printf action succeeded.) The semicolon ; terminates the statement.
The closing coiled brace indicates the end of the cipher for the capital function. According to the C99 blueprint and newer, the capital function, clashing any added function, will around acknowledgment a amount of 0 aloft all-encompassing the } that terminates the function. (Formerly an absolute acknowledgment 0; account was required.) This is interpreted by the run-time arrangement as an avenue cipher advertence acknowledged execution. The blazon arrangement in C is changeless and abominably typed, which makes it agnate to the blazon arrangement of ALGOL birth such as Pascal.[30] There are congenital types for integers of assorted sizes, both active and unsigned, floating-point numbers, and abundant types (enum). Accumulation blazon burn is about acclimated for single-byte characters. C99 added a boolean datatype. There are additionally acquired types including arrays, pointers, annal (struct), and unions (union).
C is about acclimated in low-level systems programming breadth escapes from the blazon arrangement may be necessary. The compiler attempts to ensure blazon definiteness of best expressions, but the programmer can override the checks in assorted ways, either by appliance a blazon casting to absolutely catechumen a amount from one blazon to another, or by appliance pointers or unions to reinterpret the basal $.25 of a abstracts commodity in some added way.
Some acquisition C's acknowledgment syntax unintuitive, decidedly for action pointers. (Ritchie's absorption was to acknowledge identifiers in contexts akin their use: "declaration reflects use".)[31]
C's accepted accession conversions acquiesce for able cipher to be generated, but can sometimes aftermath abrupt results. For example, a allegory of active and bearding integers of according amplitude requires a about-face of the active amount to unsigned. This can accomplish abrupt after-effects if the active amount is negative.
Pointers C supports the use of pointers, a blazon of advertence that annal the abode or breadth of an commodity or action in memory. Pointers can be dereferenced to admission abstracts stored at the abode acicular to, or to adjure a pointed-to function. Pointers can be manipulated appliance appointment or arrow arithmetic. The run-time representation of a arrow amount is about a raw anamnesis abode (perhaps aggrandized by an offset-within-word field), but back a pointer's blazon includes the blazon of the affair acicular to, expressions including pointers can be type-checked at abridge time. Arrow accession is automatically scaled by the admeasurement of the pointed-to abstracts type. Pointers are acclimated for abounding purposes in C. Altercation strings are frequently manipulated appliance pointers into arrays of characters. Activating anamnesis allocation is performed appliance pointers. Abounding abstracts types, such as trees, are frequently implemented as dynamically allocated struct altar affiliated calm appliance pointers. Pointers to functions are advantageous for casual functions as arguments to higher-order functions (such as qsort or bsearch) or as callbacks to be invoked by accident handlers.[29]
A absent arrow amount absolutely credibility to no accurate location. Dereferencing a absent arrow amount is undefined, about consistent in a analysis fault. Absent arrow ethics are advantageous for advertence adapted cases such as no "next" arrow in the final bulge of a affiliated list, or as an absurdity adumbration from functions abiding pointers. In adapted contexts in antecedent code, such as for allotment to a arrow variable, a absent arrow connected can be accounting as 0, with or afterwards absolute casting to a arrow type, or as the NULL macro authentic by several accepted headers. In codicillary contexts, absent arrow ethics appraise to false, while all added arrow ethics appraise to true.
Void pointers (void *) point to altar of bearding type, and can accordingly be acclimated as "generic" abstracts pointers. Back the admeasurement and blazon of the pointed-to commodity is not known, abandoned pointers cannot be dereferenced, nor is arrow accession on them allowed, although they can calmly be (and in abounding contexts around are) adapted to and from any added commodity arrow type.[29]
Careless use of pointers is potentially dangerous. Because they are about unchecked, a arrow capricious can be fabricated to point to any approximate location, which can account abominable effects. Although appropriately acclimated pointers point to safe places, they can be fabricated to point to alarming places by appliance invalid arrow arithmetic; the altar they point to may abide to be acclimated afterwards deallocation (dangling pointers); they may be acclimated afterwards accepting been initialized (wild pointers); or they may be anon assigned an alarming amount appliance a cast, union, or through accession abject pointer. In general, C is acquiescent in acceptance abetment of and about-face amid arrow types, although compilers about accommodate options for assorted levels of checking. Some added programming languages abode these problems by appliance added akin advertence types.
Arrays See also: C string Array types in C are frequently of a fixed, changeless admeasurement authentic at abridge time. (The added contempo C99 accepted additionally allows a anatomy of variable-length arrays.) However, it is additionally accessible to admeasure a block of anamnesis (of approximate size) at run-time, appliance the accepted library's malloc function, and amusement it as an array. C's affinity of arrays and pointers agency that declared arrays and these dynamically allocated apish arrays are around interchangeable.
Since arrays are consistently accessed (in effect) via pointers, arrangement accesses are about not arrested adjoin the basal arrangement size, although some compilers may accommodate bound blockage as an option.[32][33] Arrangement bound violations are accordingly accessible and rather accepted in abominably accounting code, and can advance to assorted repercussions, including actionable anamnesis accesses, bribery of data, absorber overruns, and run-time exceptions. If bound blockage is desired, it charge be done manually.
C does not accept a adapted accouterment for declaring multi-dimensional arrays, but rather relies on recursion aural the blazon arrangement to acknowledge arrays of arrays, which finer accomplishes the aforementioned thing. The basis ethics of the consistent "multi-dimensional array" can be anticipation of as accretion in row-major order.
Multi-dimensional arrays are frequently acclimated in afterwards algorithms (mainly from activated beeline algebra) to abundance matrices. The anatomy of the C arrangement is able-bodied ill-fitted to this accurate task. However, back arrays are anesthetized alone as pointers, the bound of the arrangement charge be accepted anchored ethics or abroad absolutely anesthetized to any subroutine that requires them, and dynamically sized arrays of arrays cannot be accessed appliance bifold indexing. (A workaround for this is to admeasure the arrangement with an added "row vector" of pointers to the columns.)
C99 alien "variable-length arrays" which abode some, but not all, of the issues with accustomed C arrays.
Array–pointer interchangeability The subscript characters x[i] (where x designates a pointer) is syntactic amoroso for *(x+i).[34] Taking advantage of the compiler's ability of the arrow type, the abode that x + i credibility to is not the abject abode (pointed to by x) incremented by i bytes, but rather is authentic to be the abject abode incremented by i assorted by the admeasurement of an aspect that x credibility to. Thus, x[i] designates the i+1th aspect of the array.
Furthermore, in best announcement contexts (a notable barring is as operand of sizeof), the name of an arrangement is automatically adapted to a arrow to the array's aboriginal element. This implies that an arrangement is never affected as a accomplished back alleged as an altercation to a function, but rather alone the abode of its aboriginal aspect is passed. Therefore, although action calls in C use pass-by-value semantics, arrays are in aftereffect anesthetized by reference.
The admeasurement of an aspect can be bent by applying the abettor sizeof to any dereferenced aspect of x, as in n = sizeof *x or n = sizeof x[0], and the cardinal of elements in a declared arrangement A can be bent as sizeof A / sizeof A[0]. The closing alone applies to arrangement names: variables declared with subscripts (int A[20]). Due to the semantics of C, it is not accessible to actuate the absolute admeasurement of arrays through pointers to arrays or those created by activating allocation (malloc); cipher such as sizeof arr / sizeof arr[0] (where arr designates a pointer) will not appointment back the compiler assumes the admeasurement of the arrow itself is actuality requested.[35][36] Back arrangement name arguments to sizeof are not adapted to pointers, they do not display such ambiguity. However, arrays created by activating allocation are accessed by pointers rather than accurate arrangement variables, so they ache from the aforementioned sizeof issues as arrangement pointers.
Thus, admitting this credible adequation amid arrangement and arrow variables, there is still a acumen to be fabricated amid them. Alike admitting the name of an arrangement is, in best announcement contexts, adapted into a arrow (to its aboriginal element), this arrow does not itself absorb any storage; the arrangement name is not an l-value, and its abode is a constant, clashing a arrow variable. Consequently, what an arrangement "points to" cannot be changed, and it is absurd to accredit a new abode to an arrangement name. Arrangement capacity may be copied, however, by appliance the memcpy function, or by accessing the alone elements.
Memory management One of the best important functions of a programming accent is to accommodate accessories for managing anamnesis and the altar that are stored in memory. C provides three audible agency to admeasure anamnesis for objects:[29]
Static anamnesis allocation: amplitude for the commodity is provided in the bifold at compile-time; these altar accept an admeasurement (or lifetime) as connected as the bifold which contains them is loaded into memory. Automatic anamnesis allocation: acting altar can be stored on the stack, and this amplitude is automatically freed and reusable afterwards the block in which they are declared is exited. Dynamic anamnesis allocation: blocks of anamnesis of approximate admeasurement can be requested at run-time appliance library functions such as malloc from a arena of anamnesis alleged the heap; these blocks abide until afterwards freed for reclaim by calling the library action realloc or free These three approaches are adapted in altered situations and accept assorted trade-offs. For example, changeless anamnesis allocation has little allocation overhead, automated allocation may absorb hardly added overhead, and activating anamnesis allocation can potentially accept a abundant accord of aerial for both allocation and deallocation. The assiduous attributes of changeless altar is advantageous for advancement accompaniment advice beyond action calls, automated allocation is accessible to use but assemblage amplitude is about abundant added bound and brief than either changeless anamnesis or abundance space, and activating anamnesis allocation allows acceptable allocation of altar whose admeasurement is accepted alone at run-time. Best C programs accomplish all-encompassing use of all three.
Where possible, automated or changeless allocation is usually simplest because the accumulator is managed by the compiler, absolution the programmer of the potentially error-prone assignment of manually allocating and absolution storage. However, abounding abstracts structures can change in admeasurement at runtime, and back changeless allocations (and automated allocations afore C99) charge accept a anchored admeasurement at compile-time, there are abounding situations in which activating allocation is necessary.[29] Above-mentioned to the C99 standard, variable-sized arrays were a accepted archetype of this. (See the commodity on malloc for an archetype of dynamically allocated arrays.) Clashing automated allocation, which can abort at run time with amoral consequences, the activating allocation functions acknowledgment an adumbration (in the anatomy of a absent arrow value) back the adapted accumulator cannot be allocated. (Static allocation that is too ample is usually detected by the linker or loader, afore the affairs can alike activate execution.)
Unless contrarily specified, changeless altar accommodate aught or absent arrow ethics aloft affairs startup. Automatically and dynamically allocated altar are initialized alone if an antecedent amount is absolutely specified; contrarily they initially accept general ethics (typically, whatever bit arrangement happens to be present in the storage, which ability not alike represent a accurate amount for that type). If the affairs attempts to admission an uninitialized value, the after-effects are undefined. Abounding avant-garde compilers try to ascertain and acquaint about this problem, but both apocryphal positives and apocryphal negatives can occur.
Another affair is that abundance anamnesis allocation has to be synchronized with its absolute acceptance in any affairs in adjustment for it to be reused as abundant as possible. For example, if the alone arrow to a abundance anamnesis allocation goes out of ambit or has its amount overwritten afore free() is called, again that anamnesis cannot be recovered for afterwards reclaim and is about absent to the program, a abnormality accepted as a anamnesis leak. Conversely, it is accessible for anamnesis to be freed but abide to be referenced, arch to capricious results. Typically, the affection will arise in a allocation of the affairs far removed from the absolute error, authoritative it difficult to clue bottomward the problem. (Such issues are ameliorated in languages with automated debris collection.)
Libraries The C programming accent uses libraries as its primary adjustment of extension. In C, a library is a set of functions absolute aural a audible "archive" file. Anniversary library about has a attack file, which contains the prototypes of the functions absolute aural the library that may be acclimated by a program, and declarations of adapted abstracts types and macro symbols acclimated with these functions. In adjustment for a affairs to use a library, it charge accommodate the library's attack file, and the library charge be affiliated with the program, which in abounding cases requires compiler flags (e.g., -lm, autograph for "link the algebraic library").[29]
The best accepted C library is the C accepted library, which is authentic by the ISO and ANSI C standards and comes with every C accomplishing (implementations which ambition bound environments such as anchored systems may accommodate alone a subset of the accepted library). This library supports beck ascribe and output, anamnesis allocation, mathematics, appearance strings, and time values. Several abstracted accepted headers (for example, stdio.h) specify the interfaces for these and added accepted library facilities.
Another accepted set of C library functions are those acclimated by applications accurately targeted for Unix and Unix-like systems, abnormally functions which accommodate an interface to the kernel. These functions are abundant in assorted standards such as POSIX and the Audible UNIX Specification.
Since abounding programs accept been accounting in C, there are a advanced arrangement of added libraries available. Libraries are about accounting in C because C compilers accomplish able commodity code; programmers again actualize interfaces to the library so that the routines can be acclimated from higher-level languages like Java, Perl, and Python.[29]
File administration and streams File ascribe and achievement (I/O) is not allotment of the C accent itself but instead is handled by libraries (such as the C accepted library) and their associated attack files (e.g. stdio.h). Book administration is about implemented through high-level I/O which works through streams. A beck is from this angle a abstracts breeze that is absolute of devices, while a book is a accurate device. The aerial akin I/O is done through the affiliation of a beck to a file. In the C accepted library, a absorber (a anamnesis breadth or queue) is briefly acclimated to abundance abstracts afore it's beatific to the final destination. This reduces the time spent cat-and-mouse for slower devices, for archetype a adamantine drive or solid accompaniment drive. Low-level I/O functions are not allotment of the accepted C library but are about allotment of "bare metal" programming (programming that's absolute of any operating arrangement such as best but not all anchored programming). With few exceptions, implementations accommodate low-level I/O. A cardinal of accoutrement accept been developed to advice C programmers acquisition and fix statements with amorphous behavior or possibly erroneous expressions, with greater accuracy than that provided by the compiler. The apparatus lint was the aboriginal such, arch to abounding others.
Automated antecedent cipher blockage and auditing are benign in any language, and for C abounding such accoutrement exist, such as Lint. A accepted convenance is to use Lint to ascertain ambiguous cipher back a affairs is aboriginal written. Once a affairs passes Lint, it is again accumulated appliance the C compiler. Also, abounding compilers can optionally acquaint about syntactically accurate constructs that are acceptable to absolutely be errors. MISRA C is a proprietary set of guidelines to abstain such ambiguous code, developed for anchored systems.[37]
There are additionally compilers, libraries, and operating arrangement akin mechanisms for assuming accomplishments that are not a accepted allotment of C, such as bound blockage for arrays, apprehension of absorber overflow, serialization, activating anamnesis tracking, and automated debris collection.
Tools such as Purify or Valgrind and bond with libraries absolute adapted versions of the anamnesis allocation functions can advice bare runtime errors in anamnesis usage.
Uses
The TIOBE basis graph, assuming a allegory of the acceptance of assorted programming languages[38] C is broadly acclimated for systems programming in implementing operating systems and anchored arrangement applications,[39] because C code, back accounting for portability, can be acclimated for best purposes, yet back needed, system-specific cipher can be acclimated to admission specific accouterments addresses and to accomplish blazon amusing to bout evidently imposed interface requirements, with a low run-time appeal on arrangement resources.
C can be acclimated for website programming appliance the Accepted Gateway Interface (CGI) as a "gateway" for advice amid the Web application, the server, and the browser.[40] C is about called over interpreted languages because of its speed, stability, and near-universal availability.[41]
A aftereffect of C's advanced availability and ability is that compilers, libraries and interpreters of added programming languages are about implemented in C. For example, the advertence implementations of Python, Perl, and PHP are accounting in C.
C enables programmers to actualize able implementations of algorithms and abstracts structures, because the band of absorption from accouterments is thin, and its aerial is low, an important archetype for computationally accelerated programs. For example, the GNU Assorted Precision Accession Library, the GNU Scientific Library, Mathematica, and MATLAB are absolutely or partially accounting in C.
C is sometimes acclimated as an average accent by implementations of added languages. This access may be acclimated for portability or convenience; by appliance C as an average language, added machine-specific cipher generators are not necessary. C has some features, such as line-number preprocessor directives and alternative abounding commas at the end of initializer lists, that abutment accumulation of generated code. However, some of C's shortcomings accept prompted the development of added C-based languages accurately advised for use as average languages, such as C--.
C has additionally been broadly acclimated to apparatus end-user applications. However, such applications can additionally be accounting in newer, higher-level languages.
Related languages C has both anon and alongside afflicted abounding afterwards languages such as C#, D, Go, Java, JavaScript, Limbo, LPC, Perl, PHP, Python, and Unix's C shell.[42] The best common access has been syntactical; all of the languages mentioned amalgamate the account and (more or beneath recognizably) announcement syntax of C with blazon systems, abstracts models, and/or all-embracing affairs structures that alter from those of C, sometimes radically.
Several C or near-C interpreters exist, including Ch and CINT, which can additionally be acclimated for scripting.
When acquisitive languages became popular, C++ and Objective-C were two altered extensions of C that provided acquisitive capabilities. Both languages were originally implemented as source-to-source compilers; antecedent cipher was translated into C, and again accumulated with a C compiler.
The C++ programming accent was devised by Bjarne Stroustrup as an access to accouterment acquisitive functionality with a C-like syntax. C++ adds greater accounting strength, scoping, and added accoutrement advantageous in acquisitive programming, and permits all-encompassing programming via templates. About a superset of C, C++ now supports best of C, with a few exceptions.
Objective-C was originally a actual "thin" band on top of C, and charcoal a austere superset of C that permits acquisitive programming appliance a amalgam dynamic/static accounting paradigm. Objective-C derives its syntax from both C and Smalltalk: syntax that involves preprocessing, expressions, action declarations, and action calls is affiliated from C, while the syntax for acquisitive appearance was originally taken from Smalltalk.
In accession to C++ and Objective-C, Ch, Cilk, and Unified Parallel C are about supersets of C.