C# Upload Document to Server Asp.net Core

General-purpose programming language

C
Major implementations
The C Programming Language ^[one] (often referred to as M&R), the seminal book on C
Paradigm	Multi-image: imperative (procedural), structured
Designed by	Dennis Ritchie
Developer	Dennis Ritchie & Bell Labs (creators); ANSI X3J11 (ANSI C); ISO/IEC JTC1/SC22/WG14 (ISO C)
First appeared	1972; 50 years ago (1972) ^[2]

Stable release	C17 / June 2018; three years ago (2018-06)
Preview release	C2x (N2731) / Oct 18, 2021; v months ago (2021-x-18) ^[3]

Typing subject area	Static, weak, manifest, nominal
Bone	Cross-platform
Filename extensions	.c, .h
Website	www.iso.org/standard/74528.html www.open-std.org/jtc1/sc22/wg14/
pcc, GCC, Clang, Intel C, C++Builder, Microsoft Visual C++, Watcom C
Dialects
Cyclone, Unified Parallel C, Separate-C, Cilk, C*
Influenced by
B (BCPL, CPL), ALGOL 68,^[iv] associates, PL/I, FORTRAN
Influenced
Numerous: AMPL, AWK, csh, C++, C--, C#, Objective-C, D, Get, Java, JavaScript, JS++, Julia, Limbo, LPC, Perl, PHP, Pike, Processing, Python, Rust, Seed7, Vala, Verilog (HDL),^[5] Nim, Zig
C Programming at Wikibooks

C (, as in the alphabetic character c) is a general-purpose figurer programming language. Information technology was created in the 1970s and remains very widely used and influential. By blueprint, C'southward features cleanly reflect the capabilities of the targetted CPUs. It has found lasting use in operating systems, device drivers, protocol stacks, though decreasingly for application software, and is common in reckoner architectures that range from the largest supercomputers to the smallest microcontrollers and embedded systems.

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. It was applied to re-implementing the kernel of the Unix operating system.^{[half dozen]} During the 1980s, C gradually gained popularity. Information technology has become one of the most widely used programming languages,^[7] ^[8] with C compilers available for the almost all mod estimator architectures and operating systems. C has been standardized past ANSI since 1989 (ANSI C) and by the International Organization for Standardization (ISO).

C is an imperative procedural language supporting structured programming, lexical variable scope, and recursion, with a static blazon system. Information technology was designed to be compiled to provide low-level access to retentivity and language constructs that map efficiently to machine instructions, all with minimal runtime support. Despite its low-level capabilities, the language was designed to encourage cross-platform programming. A standards-compliant C program written with portability in mind tin can be compiled for a wide variety of reckoner platforms and operating systems with few changes to its source lawmaking.^[9]

Since 2000, C has consistently ranked amongst the height two languages in the TIOBE alphabetize, a mensurate of the popularity of programming languages.^[10]

Overview [edit]

C is an imperative, procedural language in the ALGOL tradition. It has a static type system. In C, all executable lawmaking is independent within subroutines (also called "functions", though not in the sense of functional programming). Part parameters are passed past value, although arrays are passed as pointers, i.e. the accost of the first item in the array. Pass-by-reference is simulated in C by explicitly passing pointers to the thing beingness referenced.

C program source text is free-format, using the semicolon as a statement separator and curly braces for grouping blocks of statements.

The C language also exhibits the following characteristics:

The linguistic communication has a small, fixed number of keywords, including a total gear up of control menstruation primitives: if/else, for, do/while, while, and switch. User-defined names are not distinguished from keywords by any kind of sigil.
It has a large number of arithmetic, bitwise, and logic operators: +,+=,++,&,||, etc.
More than 1 assignment may be performed in a single argument.
Functions:
- Office return values can exist ignored, when not needed.
- Function and data pointers let advert hoc run-time polymorphism.
- Functions may not exist defined within the lexical telescopic of other functions.
- Variables may exist defined within a function, with scope.
- A office may call itself, and so recursion is supported.
Information typing is static, but weakly enforced; all data has a blazon, but implicit conversions are possible.
User-divers (typedef) and compound types are possible.
- Heterogeneous aggregate data types (struct) allow related data elements to exist accessed and assigned as a unit.
- Wedlock is a construction with overlapping members; only the last member stored is valid.
- Array indexing is a secondary notation, defined in terms of pointer arithmetic. Unlike structs, arrays are not first-grade objects: they cannot be assigned or compared using single built-in operators. There is no "assortment" keyword in utilize or definition; instead, foursquare brackets indicate arrays syntactically, for case month[11].
- Enumerated types are possible with the enum keyword. They are freely interconvertible with integers.
- Strings are not a distinct data type, but are conventionally implemented as null-terminated grapheme arrays.
Low-level access to computer memory is possible by converting motorcar addresses to pointers.
Procedures (subroutines not returning values) are a special case of office, with an untyped return type void.
Memory can be allocated to a plan with calls to library routines.
A preprocessor performs macro definition, source code file inclusion, and provisional compilation.
There is a basic form of modularity: files can be compiled separately and linked together, with control over which functions and information objects are visible to other files via static and extern attributes.
Complex functionality such as I/O, cord manipulation, and mathematical functions are consistently delegated to library routines.
The generated code after compilation has relatively straightforward needs on the underlying platform, which makes it suitable for creating operating systems and for use in embedded systems.

While C does not include sure 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 (due east.g., the GLib Object System or the Boehm garbage collector).

Relations to other languages [edit]

Many afterward languages have borrowed directly or indirectly from C, including C++, C#, Unix's C shell, D, Get, Coffee, JavaScript (including transpilers), Julia, Limbo, LPC, Objective-C, Perl, PHP, Python, Ruby, Rust, Swift, Verilog and SystemVerilog (hardware description languages).^[5] These languages have drawn many of their command structures and other basic features from C. Well-nigh of them (Python existence a dramatic exception) too express highly like 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 exist radically unlike.

History [edit]

Early developments [edit]

Timeline of language development
Yr	C Standard^[9]
1972	Birth
1978	K&R C
1989/1990	ANSI C and ISO C
1999	C99
2011	C11
2017	C17
TBD	C2x

The origin of C is closely tied to the development of the Unix operating system, originally implemented in assembly linguistic communication on a PDP-seven past Dennis Ritchie and Ken Thompson, incorporating several ideas from colleagues. Eventually, they decided to port the operating system to a PDP-11. The original PDP-xi version of Unix was also developed in associates language.^[6]

Thompson desired a programming language to make utilities for the new platform. At get-go, he tried to brand a Fortran compiler, just soon gave up the idea. Instead, he created a cut-downwardly version of the recently developed BCPL systems programming language. The official description of BCPL was non available at the time,^[11] and Thompson modified the syntax to be less wordy, and similar to a simplified ALGOL known as SMALGOL.^[12] The result was the like just somewhat simpler linguistic communication he called B.^[6] Like BCPL, B had a bootstrapping compiler to facilitate porting to new machines.^[12] Thompson described B as "BCPL semantics with a lot of SMALGOL syntax".^[12] However, few utilities were ultimately written in B because it was too ho-hum, and B could non take advantage of PDP-11 features such as byte addressability.

In 1971, Ritchie started to improve B, to apply the features of the more-powerful PDP-xi. A significant add-on was a character type. He called this New B.^[12] Thompson started to utilize NB to write the Unix kernel, and his requirements shaped the direction of the language evolution.^[12] ^[13] Through to 1972, richer types were added to the NB language: NB had arrays of int and char; just then were added pointers, power to generate pointers to other types, arrays of all of these, types to be returned from functions. Arrays within expressions became pointers. A new compiler was written, and the linguistic communication was renamed to C. ^[vi]

The C compiler and some utilities made with information technology were included in Version ii Unix.^[xiv]

At Version iv Unix, released in November 1973, the Unix kernel was extensively re-implemented in C.^[6] By this time, the C language had acquired some powerful features such as struct types.

The preprocessor was introduced around 1973 at the urging of Alan Snyder and also in recognition of the usefulness of the file-inclusion mechanisms bachelor in BCPL and PL/I. Its original version provided but included files and uncomplicated cord replacements: #include and #define of parameterless macros. Soon later that, it was extended, generally by Mike Lesk and then by John Reiser, to incorporate macros with arguments and conditional compilation.^[6]

Unix was 1 of the get-go operating system kernels implemented in a language other than assembly. Earlier instances include the Multics system (which was written in PL/I) and Master Command Program (MCP) for the Burroughs B5000 (which was written in ALGOL) in 1961. In around 1977, Ritchie and Stephen C. Johnson fabricated farther changes to the language to facilitate portability of the Unix operating system. Johnson's Portable C Compiler served as the basis for several implementations of C on new platforms.^[13]

One thousand&R C [edit]

In 1978, Brian Kernighan and Dennis Ritchie published the kickoff edition of The C Programming Language.^[1] This book, known to C programmers as K&R, served for many years equally an informal specification of the language. The version of C that it describes is commonly referred to as "G&R C". Equally this was released in 1978, it is as well referred to every bit C78.^[15] The 2d edition of the book^[16] covers the subsequently ANSI C standard, described below.

Thousand&R introduced several linguistic communication features:

Standard I/O library
long int data type
unsigned int data type
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 every bit i=-10, which had been interpreted as i =- 10 (decrement i past 10) instead of the possibly intended i = -ten (permit i be −x).

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

In early versions of C, only functions that render types other than int must be alleged if used earlier the part definition; functions used without prior announcement were presumed to render blazon int.

For example:

                        long                                    some_function            ();                        /* int */                                    other_function            ();                        /* int */                                    calling_function            ()                        {                                                long                                    test1            ;                                                annals                                    /* int */                                    test2            ;                                                test1                                    =                                    some_function            ();                                                if                                    (            test1                                    >                                    one            )                                                test2                                    =                                    0            ;                                                else                                                test2                                    =                                    other_function            ();                                                return                                    test2            ;                        }

The int blazon specifiers which are commented out could exist omitted in G&R C, just are required in later on standards.

Since Chiliad&R office declarations did not include any information about role arguments, function parameter blazon checks were non performed, although some compilers would event a warning message if a local office was chosen with the wrong number of arguments, or if multiple calls to an external function used dissimilar numbers or types of arguments. Split up tools such as Unix'due south lint utility were developed that (amidst other things) could bank check for consistency of function use across multiple source files.

In the years following the publication of Thousand&R C, several features were added to the language, supported by compilers from AT&T (in particular PCC^[17]) and some other vendors. These included:

void functions (i.east., functions with no render value)
functions returning struct or wedlock types (rather than pointers)
assignment for struct data types
enumerated types

The big number of extensions and lack of agreement on a standard library, together with the language popularity and the fact that non fifty-fifty the Unix compilers precisely implemented the M&R specification, led to the necessity of standardization.^{[ commendation needed ]}

ANSI C and ISO C [edit]

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.

In 1983, the American National Standards Found (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. In 1989, the C standard was ratified as ANSI X3.159-1989 "Programming Linguistic communication C". This version of the language is often referred to every bit ANSI C, Standard C, or sometimes C89.

In 1990, the ANSI C standard (with formatting changes) was adopted by the International Organisation for Standardization (ISO) as ISO/IEC 9899:1990, which is sometimes chosen C90. Therefore, the terms "C89" and "C90" refer to the aforementioned programming language.

ANSI, similar other national standards bodies, no longer develops the C standard independently, but defers to the international C standard, maintained by the working grouping ISO/IEC JTC1/SC22/WG14. National adoption of an update to the international standard typically occurs within a year of ISO publication.

One of the aims of the C standardization process was to produce a superset of K&R C, incorporating many of the later on introduced unofficial features. The standards committee as well included several additional features such as role prototypes (borrowed from C++), void pointers, support for international character sets and locales, and preprocessor enhancements. Although the syntax for parameter declarations was augmented to include the fashion used in C++, the G&R interface continued to exist permitted, for compatibility with existing source code.

C89 is supported past current C compilers, and most mod C code is based on it. Whatsoever program written only in Standard C and without any hardware-dependent assumptions volition run correctly on whatever platform with a conforming C implementation, within its resources limits. Without such precautions, programs may compile only on a sure platform or with a particular compiler, due, for example, to the apply 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.

In cases where lawmaking must be compilable by either standard-conforming or G&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 G&R C-based compiler of features available only in Standard C.

After the ANSI/ISO standardization process, the C language specification remained relatively static for several years. In 1995, Normative Amendment 1 to the 1990 C standard (ISO/IEC 9899/AMD1:1995, known informally as C95) was published, to right some details and to add more extensive support for international character sets.^[18]

C99 [edit]

The C standard was farther revised in the late 1990s, leading to the publication of ISO/IEC 9899:1999 in 1999, which is usually referred to every bit "C99". Information technology has since been amended three times past Technical Corrigenda.^[19]

C99 introduced several new features, including inline functions, several new data types (including long long int and a complex type to stand for circuitous numbers), variable-length arrays and flexible array members, improved back up 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++. Many of these had already been implemented equally extensions in several C compilers.

C99 is for the nigh part backward compatible with C90, only is stricter in some ways; in item, a proclamation that lacks a type specifier no longer has int implicitly assumed. A standard macro __STDC_VERSION__ is defined with value 199901L to point that C99 support is bachelor. GCC, Solaris Studio, and other C compilers at present support many or all of the new features of C99. The C compiler in Microsoft Visual C++, nevertheless, implements the C89 standard and those parts of C99 that are required for compatibility with C++11.^[xx] ^{[ needs update ]}

In add-on, support for Unicode identifiers (variable / function names) in the form of escaped characters (east.g. \U0001f431) is now required. Support for raw Unicode names is optional.

C11 [edit]

In 2007, work began on another revision of the C standard, informally called "C1X" until its official publication on 2011-12-08. The C standards commission adopted guidelines to limit the adoption of new features that had not been tested by existing implementations.

The C11 standard adds numerous new features to C and the library, including blazon generic macros, anonymous structures, improved Unicode support, atomic operations, multi-threading, and bounds-checked functions. It likewise makes some portions of the existing C99 library optional, and improves compatibility with C++. The standard macro __STDC_VERSION__ is defined every bit 201112L to bespeak that C11 support is bachelor.

C17 [edit]

Published in June 2018, C17 is the current standard for the C programming language. It introduces no new language features, only technical corrections, and clarifications to defects in C11. The standard macro __STDC_VERSION__ is defined as 201710L.

C2x [edit]

C2x is an breezy proper name for the next (after C17) major C language standard revision. Information technology is expected to be voted on in 2023 and would therefore exist chosen C23.^[21] ^{[ improve source needed ]}

Embedded C [edit]

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

In 2008, the C Standards Committee published a technical report extending the C linguistic communication^[22] to address these issues by providing a mutual standard for all implementations to adhere to. Information technology includes a number of features not bachelor in normal C, such as stock-still-signal arithmetics, named address spaces, and bones I/O hardware addressing.

Syntax [edit]

C has a formal grammar specified by the C standard.^[23] Line endings are generally not significant in C; even so, line boundaries do accept significance during the preprocessing phase. Comments may appear either between the delimiters /* and */, or (since C99) post-obit // until the end of the line. Comments delimited by /* and */ exercise non nest, and these sequences of characters are not interpreted equally comment delimiters if they appear inside string or graphic symbol literals.^[24]

C source files contain declarations and function definitions. Function definitions, in plow, contain declarations and statements. Declarations either define new types using keywords such as struct, spousal relationship, and enum, or assign types to and perhaps reserve storage for new variables, commonly by writing the type followed by the variable name. Keywords such every bit char and int specify built-in types. Sections of code are enclosed in braces ({ and }, sometimes called "curly brackets") to limit the scope of declarations and to human activity as a unmarried statement for control structures.

As an imperative language, C uses statements to specify actions. The near common statement is an expression argument, consisting of an expression to exist evaluated, followed by a semicolon; as a side event of the evaluation, functions may exist called and variables may exist assigned new values. To modify the normal sequential execution of statements, C provides several control-flow statements identified by reserved keywords. Structured programming is supported by if … [else] conditional execution and by do … while, while, and for iterative execution (looping). The for statement has separate initialization, testing, and reinitialization expressions, any or all of which tin exist omitted. break and continue can be used to leave the innermost enclosing loop statement or skip to its reinitialization. There is also a non-structured goto statement which branches directly to the designated characterization within the function. switch selects a case to be executed based on the value of an integer expression.

Expressions tin can use a diverseness of built-in operators and may contain role calls. The order in which arguments to functions and operands to most operators are evaluated is unspecified. The evaluations may even be interleaved. Yet, all side effects (including storage to variables) will occur before the next "sequence point"; sequence points include the stop of each expression statement, and the entry to and return from each office call. Sequence points likewise occur during evaluation of expressions containing certain operators (&&, ||, ?: and the comma operator). This permits a high degree of object code optimization by the compiler, only requires C programmers to have more care to obtain reliable results than is needed for other programming languages.

Kernighan and Ritchie say in the Introduction of The C Programming Language: "C, like whatsoever other language, has its blemishes. Some of the operators have the incorrect precedence; some parts of the syntax could be better."^[25] The C standard did not endeavour to right many of these blemishes, considering of the impact of such changes on already existing software.

Character set [edit]

The basic C source character set includes the following characters:

Lowercase and capital letter letters of ISO Bones Latin Alphabet: a–z A–Z
Decimal digits: 0–nine
Graphic characters: ! " # % & ' ( ) * + , - . / : ; < = > ? [ \ ] ^ _ { | } ~
Whitespace characters: space, horizontal tab, vertical tab, form feed, newline

Newline indicates the end of a text line; it need non correspond to an actual single grapheme, although for convenience C treats it as one.

Additional multi-byte encoded characters may exist used in cord literals, but they are not entirely portable. The latest C standard (C11) allows multi-national Unicode characters to be embedded portably within C source text past using \uXXXX or \UXXXXXXXX encoding (where the X denotes a hexadecimal character), although this characteristic is not even so widely implemented.

The basic C execution grapheme gear up contains the same characters, along with representations for warning, backspace, and wagon return. Run-time support for extended character sets has increased with each revision of the C standard.

Reserved words [edit]

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:

machine
break
case
char
const
continue
default
do
double
else
enum
extern
float
for
goto
if
int
long
annals
return
brusque
signed
sizeof
static
struct
switch
typedef
union
unsigned
void
volatile
while

C99 reserved five more words:

_Bool
_Complex
_Imaginary
inline
restrict

C11 reserved vii more words:^[26]

_Alignas
_Alignof
_Atomic
_Generic
_Noreturn
_Static_assert
_Thread_local

Most of the recently reserved words begin with an underscore followed by a capital alphabetic character, because identifiers of that form were previously reserved by the C standard for utilize but by implementations. Since existing plan source code should non accept been using these identifiers, information technology would non be affected when C implementations started supporting these extensions to the programming language. Some standard headers exercise define more convenient synonyms for underscored identifiers. The language previously included a reserved discussion chosen entry, but this was seldom implemented, and has now been removed as a reserved word.^[27]

Operators [edit]

C supports a rich fix of operators, which are symbols used within an expression to specify the manipulations to be performed while evaluating that expression. C has operators for:

arithmetic: +, -, *, /, %
consignment: =
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 group: ( )
type conversion: (typename)

C uses the operator = (used in mathematics to limited equality) to indicate assignment, post-obit the precedent of Fortran and PL/I, simply different ALGOL and its derivatives. C uses the operator == to test for equality. The similarity between these two operators (assignment and equality) may effect in the accidental employ of 1 in place of the other, and in many cases, the error does not produce an fault message (although some compilers produce warnings). For example, the provisional expression if (a == b + ane) might mistakenly exist written as if (a = b + one), which will be evaluated every bit true if a is not zippo after the assignment.^[28]

The C operator precedence is not always intuitive. For example, the operator == binds more than tightly than (is executed prior to) the operators & (bitwise AND) and | (bitwise OR) in expressions such as ten & 1 == 0, which must exist written as (x & 1) == 0 if that is the coder's intent.^[29]

"Hello, globe" instance [edit]

The "how-do-you-do, globe" case, which appeared in the start edition of K&R, has become the model for an introductory program in most programming textbooks. The programme prints "hello, world" to the standard output, which is commonly a final or screen display.

The original version was:^[thirty]

                        main            ()                        {                                                printf            (            "hello, world            \n            "            );                        }

A standard-conforming "hello, globe" program is:^[a]

                        #include                                    <stdio.h>                        int                                    main            (            void            )                        {                                                printf            (            "hello, world            \n            "            );                        }

The kickoff line of the program contains a preprocessing directive, indicated past #include. This causes the compiler to replace that line with the unabridged text of the stdio.h standard header, which contains declarations for standard input and output functions such as printf and scanf. 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 aforementioned proper noun, as opposed to double quotes which typically include local or project-specific header files.

The side by side line indicates that a function named primary is beingness defined. The principal function serves a special purpose in C programs; the run-time environment calls the main function to begin program execution. The type specifier int indicates that the value that is returned to the invoker (in this case the run-time environment) as a event of evaluating the chief function, is an integer. The keyword void every bit a parameter list indicates that this function takes no arguments.^[b]

The opening curly brace indicates the starting time of the definition of the primary function.

The next line calls (diverts execution to) a office named printf, which in this case is supplied from a system library. In this call, the printf part is passed (provided with) a single argument, the address of the first character in the string literal "hi, world\northward". The string literal is an unnamed array with elements of blazon char, gear up up automatically by the compiler with a final 0-valued character to mark the end of the array (printf needs to know this). The \n is an escape sequence that C translates to a newline character, which on output signifies the stop of the electric current line. The return value of the printf function is of type int, but information technology is silently discarded since it is non used. (A more conscientious plan might test the return value to determine whether or not the printf part succeeded.) The semicolon ; terminates the statement.

The closing curly caryatid indicates the end of the code for the primary function. According to the C99 specification and newer, the main function, unlike whatsoever other function, volition implicitly return a value of 0 upon reaching the } that terminates the function. (Formerly an explicit return 0; statement was required.) This is interpreted by the run-time system as an go out code indicating successful execution.^[31]

Data types [edit]

The type system in C is static and weakly typed, which makes it similar to the type system of ALGOL descendants such as Pascal.^[32] There are built-in types for integers of various sizes, both signed and unsigned, floating-indicate numbers, and enumerated types (enum). Integer type char is often used for single-byte characters. C99 added a boolean datatype. There are also derived types including arrays, pointers, records (struct), and unions (union).

C is oftentimes used in low-level systems programming where escapes from the type organisation may be necessary. The compiler attempts to ensure type correctness of almost expressions, only the programmer tin can override the checks in diverse ways, either by using a type cast to explicitly convert a value from one type to some other, or by using pointers or unions to reinterpret the underlying bits of a data object in some other way.

Some discover C's declaration syntax unintuitive, peculiarly for part pointers. (Ritchie'southward idea was to declare identifiers in contexts resembling their use: "declaration reflects utilize".)^[33]

C's usual arithmetic conversions allow for efficient code to be generated, but can sometimes produce unexpected results. For example, a comparing of signed and unsigned integers of equal width requires a conversion of the signed value to unsigned. This can generate unexpected results if the signed value is negative.

Pointers [edit]

C supports the employ of pointers, a type of reference that records the address or location of an object or function in retentiveness. Pointers tin be dereferenced to access data stored at the address pointed to, or to invoke a pointed-to function. Pointers can be manipulated using assignment or pointer arithmetic. The run-time representation of a pointer value is typically a raw retention accost (perhaps augmented by an kickoff-inside-word field), but since a pointer's type includes the type of the matter pointed to, expressions including pointers can be type-checked at compile time. Pointer arithmetic is automatically scaled by the size of the pointed-to data blazon. Pointers are used for many purposes in C. Text strings are usually manipulated using pointers into arrays of characters. Dynamic retentivity allotment is performed using pointers. Many data types, such as trees, are usually implemented every bit dynamically allocated struct objects linked together using pointers. Pointers to functions are useful for passing functions every bit arguments to higher-order functions (such equally qsort or bsearch) or equally callbacks to be invoked by consequence handlers.^[31]

A null pointer value explicitly points to no valid location. Dereferencing a null pointer value is undefined, often resulting in a segmentation fault. Zippo pointer values are useful for indicating special cases such as no "next" pointer in the final node of a linked list, or as an mistake indication from functions returning pointers. In appropriate contexts in source code, such as for assigning to a pointer variable, a null pointer abiding tin exist written as 0, with or without explicit casting to a pointer type, or every bit the Zilch macro defined by several standard headers. In conditional contexts, zip pointer values evaluate to faux, while all other pointer values evaluate to truthful.

Void pointers (void *) point to objects of unspecified type, and tin therefore be used as "generic" information pointers. Since the size and blazon of the pointed-to object is not known, void pointers cannot be dereferenced, nor is pointer arithmetic on them allowed, although they can easily be (and in many contexts implicitly are) converted to and from any other object pointer type.^[31]

Devil-may-care use of pointers is potentially dangerous. Because they are typically unchecked, a pointer variable tin can be made to point to any arbitrary location, which can cause undesirable furnishings. Although properly used pointers bespeak to rubber places, they tin can be made to point to unsafe places by using invalid pointer arithmetics; the objects they point to may keep to be used afterwards deallocation (dangling pointers); they may be used without having been initialized (wild pointers); or they may be directly assigned an unsafe value using a cast, union, or through some other corrupt arrow. In general, C is permissive in allowing manipulation of and conversion betwixt pointer types, although compilers typically provide options for various levels of checking. Some other programming languages accost these problems by using more than restrictive reference types.

Arrays [edit]

Array types in C are traditionally of a fixed, static size specified at compile fourth dimension. The more recent C99 standard besides allows a course of variable-length arrays. However, information technology is also possible to allocate a block of retention (of arbitrary size) at run-time, using the standard library's malloc function, and treat information technology as an array.

Since arrays are always accessed (in effect) via pointers, array accesses are typically not checked confronting the underlying assortment size, although some compilers may provide bounds checking as an option.^[34] ^[35] Assortment bounds violations are therefore possible and can atomic number 82 to various repercussions, including illegal retentivity accesses, abuse of information, buffer overruns, and run-time exceptions.

C does not have a special provision for declaring multi-dimensional arrays, simply rather relies on recursion within the type system to declare arrays of arrays, which finer accomplishes the same thing. The index values of the resulting "multi-dimensional array" tin can be idea of equally increasing in row-major guild. Multi-dimensional arrays are usually used in numerical algorithms (mainly from applied linear algebra) to store matrices. The construction of the C array is well suited to this particular job. Still, in early versions of C the bounds of the array must be known fixed values or else explicitly passed to any subroutine that requires them, and dynamically sized arrays of arrays cannot be accessed using double indexing. (A workaround for this was to allocate the array with an additional "row vector" of pointers to the columns.) C99 introduced "variable-length arrays" which address this issue.

The post-obit example using modern C (C99 or later) shows allocation of a ii-dimensional assortment on the heap and the employ of multi-dimensional assortment indexing for accesses (which can use bounds-checking on many C compilers):

                        int                                    func            (            int                                    Due north            ,                                    int                                    M            )                        {                                                float                                    (            *            p            )[            N            ][            M            ]                                    =                                    malloc            (            sizeof                                    *            p            );                                                if                                    (            !            p            )                                                return                                    -ane            ;                                                for                                    (            int                                    i                                    =                                    0            ;                                    i                                    <                                    N            ;                                    i            ++            )                                                for                                    (            int                                    j                                    =                                    0            ;                                    j                                    <                                    Chiliad            ;                                    j            ++            )                                                (            *            p            )[            i            ][            j            ]                                    =                                    i                                    +                                    j            ;                                                print_array            (            N            ,                                    M            ,                                    p            );                                                free            (            p            );                                                return                                    1            ;                        }

And here is a similar implementation using C99's Automobile VLA characteristic:

                        int                                    func            (            int                                    Northward            ,                                    int                                    M            )                        {                                                // Caution: checks should be made to ensure N*M*sizeof(float) does Non exceed limitations for car VLAs and is within available size of stack.                                    float                                    p            [            N            ][            M            ];                                    // auto VLA is held on the stack, and sized when the function is invoked                                    for                                    (            int                                    i                                    =                                    0            ;                                    i                                    <                                    Due north            ;                                    i            ++            )                                                for                                    (            int                                    j                                    =                                    0            ;                                    j                                    <                                    M            ;                                    j            ++            )                                                p            [            i            ][            j            ]                                    =                                    i                                    +                                    j            ;                                                // no need to free(p) since it will disappear when the part exits, along with the residual of the stack frame                                    return                                    i            ;                        }

Array–pointer interchangeability [edit]

The subscript notation x[i] (where 10 designates a pointer) is syntactic sugar for *(ten+i).^[36] Taking reward of the compiler'south cognition of the pointer blazon, the address that 10 + i points to is not the base accost (pointed to past x) incremented by i bytes, but rather is defined to exist the base address incremented by i multiplied by the size of an element that 10 points to. Thus, x[i] designates the i+1th element of the array.

Furthermore, in almost expression contexts (a notable exception is as operand of sizeof), an expression of assortment type is automatically converted to a pointer to the assortment'south first element. This implies that an array is never copied as a whole when named as an argument to a part, but rather only the address of its first element is passed. Therefore, although function calls in C use pass-by-value semantics, arrays are in consequence passed by reference.

The total size of an array ten can be determined past applying sizeof to an expression of array type. The size of an element can exist determined past applying the operator sizeof to whatever dereferenced element of an array A, as in northward = sizeof A[0]. This, the number of elements in a declared assortment A can exist adamant as sizeof A / sizeof A[0]. Note, that if only a arrow to the offset element is available equally it is oft the example in C code considering of the automated conversion described higher up, the data almost the full blazon of the assortment and its length are lost.

Retention direction [edit]

One of the nearly important functions of a programming language is to provide facilities for managing memory and the objects that are stored in memory. C provides iii primary ways to allocate memory for objects:^[31]

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 retentiveness.
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.
Dynamic retention allocation: blocks of retention of capricious size can exist 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 gratuitous

These three approaches are appropriate in different situations and have diverse trade-offs. For example, static memory allocation has lilliputian allocation overhead, automatic allocation may involve slightly more overhead, and dynamic memory resource allotment can potentially have a great deal of overhead for both allotment and deallocation. The persistent nature of static objects is useful for maintaining state data beyond function calls, automatic allocation is easy to utilize only stack space is typically much more express and transient than either static retentiveness or heap space, and dynamic memory allocation allows convenient allocation of objects whose size is known but at run-time. Near C programs make all-encompassing apply of all three.

Where possible, automatic or static allocation is commonly simplest because the storage is managed by the compiler, freeing the programmer of the potentially error-decumbent chore of manually allocating and releasing storage. However, many data structures tin can change in size at runtime, and since static allocations (and automated allocations earlier C99) must have a stock-still size at compile-time, there are many situations in which dynamic allocation is necessary.^[31] Prior to the C99 standard, variable-sized arrays were a common example of this. (See the article on malloc for an example of dynamically allocated arrays.) Different automated allotment, which can fail at run time with uncontrolled consequences, the dynamic resource allotment functions return an indication (in the class of a goose egg pointer value) when the required storage cannot be allocated. (Static allocation that is also big is ordinarily detected by the linker or loader, before the program tin can fifty-fifty begin execution.)

Unless otherwise specified, static objects comprise zilch or zero arrow values upon program startup. Automatically and dynamically allocated objects are initialized merely if an initial value is explicitly specified; otherwise they initially take indeterminate values (typically, any flake design happens to be present in the storage, which might not even correspond a valid value for that type). If the program attempts to access an uninitialized value, the results are undefined. Many modern compilers effort to detect and warn almost this problem, merely both false positives and simulated negatives can occur.

Heap memory allotment has to be synchronized with its bodily usage in whatever program to exist reused equally much as possible. For instance, if the only pointer to a heap retention allocation goes out of scope or has its value overwritten earlier it is deallocated explicitly, then that memory cannot be recovered for later reuse and is essentially lost to the programme, a phenomenon known equally a retention leak. Conversely, it is possible for memory to be freed, but is referenced subsequently, leading to unpredictable results. Typically, the failure symptoms announced in a portion of the programme unrelated to the code that causes the error, making it difficult to diagnose the failure. Such issues are ameliorated in languages with automatic garbage collection.

Libraries [edit]

The C programming language uses libraries as its primary method of extension. In C, a library is a set up of functions contained within a single "archive" file. Each library typically has a header file, which contains the prototypes of the functions contained within the library that may be used past a programme, and declarations of special data types and macro symbols used with these functions. In social club for a programme to use a library, it must include the library's header file, and the library must exist linked with the program, which in many cases requires compiler flags (eastward.yard., -lm, shorthand for "link the math library").^[31]

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). This library supports stream input and output, memory allocation, mathematics, grapheme strings, and time values. Several split up standard headers (for example, stdio.h) specify the interfaces for these and other standard library facilities.

Another common fix of C library functions are those used past applications specifically targeted for Unix and Unix-like systems, especially functions which provide an interface to the kernel. These functions are detailed in various standards such as POSIX and the Single UNIX Specification.

Since many programs have been written in C, in that location are a wide variety of other libraries bachelor. 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 college-level languages like Java, Perl, and Python.^[31]

File handling and streams [edit]

File input and output (I/O) is not part of the C language itself simply instead is handled by libraries (such as the C standard library) and their associated header files (e.g. stdio.h). File treatment is generally implemented through high-level I/O which works through streams. A stream is from this perspective a data period that is independent of devices, while a file is a concrete device. The loftier-level I/O is done through the association of a stream to a file. In the C standard library, a buffer (a retention area or queue) is temporarily used to shop data before it'due south sent to the final destination. This reduces the time spent waiting for slower devices, for instance a hard bulldoze or solid state bulldoze. Depression-level I/O functions are not part of the standard C library^{[ clarification needed ]} but are by and large part of "bare metal" programming (programming that's independent of any operating arrangement such as almost embedded programming). With few exceptions, implementations include low-level I/O.

Language tools [edit]

A number of tools accept been developed to assist C programmers detect and fix statements with undefined behavior or perhaps erroneous expressions, with greater rigor than that provided by the compiler. The tool lint was the starting time such, leading to many others.

Automated source code checking and auditing are beneficial in whatever language, and for C many such tools exist, such every bit Lint. A mutual practice is to use Lint to detect questionable code when a program is first written. Once a plan passes Lint, it is then compiled using the C compiler. Also, many compilers can optionally warn nigh syntactically valid constructs that are likely to actually be errors. MISRA C is a proprietary set of guidelines to avert such questionable code, developed for embedded systems.^[37]

In that location are also compilers, libraries, and operating system level mechanisms for performing actions that are not a standard part of C, such every bit bounds checking for arrays, detection of buffer overflow, serialization, dynamic retentivity tracking, and automated garbage collection.

Tools such as Purify or Valgrind and linking with libraries containing special versions of the memory allocation functions tin help uncover runtime errors in retention usage.

Uses [edit]

The C Programming Language

C is widely used for systems programming in implementing operating systems and embedded system applications.^[38] This is for several reasons:

The lawmaking generated after compilation doesn't demand many system features, and tin can exist invoked from some kicking code in a straightforward mode - it'south uncomplicated to execute.
The C language statements and expressions typically map well on to sequences of instructions for the target processor, and consequently there is a low run-time demand on system resources - it's fast to execute.
The linguistic communication makes information technology easy to overlay structures onto blocks of binary data, allowing the data to exist comprehended, navigated and modified - it can write data structures, even file systems.
The linguistic communication supports a rich prepare of operators, including bit manipulation, for integer arithmetic and logic, and perhaps unlike sizes of floating point numbers - it can process appropriately-structured information effectively.
Platform hardware can be accessed with pointers and type punning, so system-specific features (e.grand. Command/Status Registers, I/O registers) can be configured and used with code written in C - information technology interacts well with the platform information technology'due south running on.
Depending on the linker and environment, C code tin can likewise telephone call libraries written in assembly language, and may be chosen from assembly language - it interoperates well with other lawmaking.
C has a very mature and broad ecosystem, including open up source compilers, debuggers and utilities, and is the de-facto standard. Information technology's likely the drivers already exist in C, or that there is a similar CPU architecture as a back-end of a C compiler, so there is reduced incentive to cull another language.

Historically, C was sometimes used for web development using the Mutual Gateway Interface (CGI) as a "gateway" for data betwixt the web application, the server, and the browser.^[39] C may have been chosen over interpreted languages considering of its speed, stability, and near-universal availability.^[forty] It is no longer common practice for web development to be done in C,^[41] and many other spider web development tools exist.

A upshot 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, Ruby, and PHP are written in C.

C enables programmers to create efficient implementations of algorithms and data structures, considering the layer of brainchild from hardware is thin, and its overhead is depression, an important criterion for computationally intensive programs. For example, the GNU Multiple Precision Arithmetics Library, the GNU Scientific Library, Mathematica, and MATLAB are completely or partially written in C. Many languages back up calling library functions in C, for case, the Python-based framework NumPy uses C for the high-performance and hardware-interacting aspects.

C is sometimes used as an intermediate language by implementations of other languages. This approach may be used for portability or convenience; by using C every bit an intermediate language, additional machine-specific code generators are not necessary. C has some features, such as line-number preprocessor directives and optional superfluous commas at the end of initializer lists, that back up compilation of generated code. Notwithstanding, some of C'south shortcomings have prompted the development of other C-based languages specifically designed for use equally intermediate languages, such as C--.

C has also been widely used to implement end-user applications.^{[ citation needed ]} However, such applications can also exist written in newer, higher-level languages.

Limitations [edit]

While C has been popular, influential and hugely successful, information technology has drawbacks, including:

The employ of pointers and the direct manipulation of memory means corruption of memory is possible, mayhap due to programmer error, or insufficient checking of bad data.
Since the lawmaking generated past the compiler contains few checks itself, there is a burden on the developer to consider all possible outcomes, and protect against buffer overruns, array bounds checking, stack overflows, memory exhaustion, race weather, thread isolation, etc.
The use of pointers and the run-time manipulation of these means there may exist two ways to access the same data (aliasing), which is not determinable at compile time. This ways that some optimisations that may be available to other languages are not possible in C. FORTRAN is considered faster.
There is limited standardisation in support for low-level variants in generated code, for example: different function calling conventions; different construction packing conventions; different byte ordering within larger integers (including endianness). In many language implementations, some of these options may be handled with the preprocessor directive #pragma,^[42] and some with additional keywords eastward.k. apply __cdecl calling convention. Only the directive and options are not consistently supported.^[43]
The language does not straight back up object orientation, introspection, run-time expression evaluation, generics, exceptions.
There are few guards against inappropriate use of language features, which may lead to unmaintainable lawmaking.

For some purposes, restricted styles of C have been adopted, e.g. MISRA C, in an attempt to reduce the opportunity for bugs. There are tools that tin mitigate against some of these drawbacks. Some of these drawbacks have prompted the construction of other languages.

[edit]

The TIOBE index graph, showing a comparing of the popularity of diverse programming languages^[44]

C has both direct and indirectly influenced many later languages such as C#, D, Become, Java, JavaScript, Limbo, LPC, Perl, PHP, Python, and Unix's C beat out.^[45] 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, information models, and/or large-calibration program structures that differ from those of C, sometimes radically.

Several C or near-C interpreters exist, including Ch and CINT, which can also exist used for scripting.

When object-oriented programming languages became popular, C++ and Objective-C were 2 different extensions of C that provided object-oriented capabilities. Both languages were originally implemented as source-to-source compilers; source code was translated into C, and and so compiled with a C compiler.^[46]

The C++ programming language (originally named "C with Classes") was devised by Bjarne Stroustrup as an approach to providing object-oriented functionality with a C-like syntax.^[47] C++ adds greater typing strength, scoping, and other tools useful in object-oriented programming, and permits generic programming via templates. Almost a superset of C, C++ now supports almost of C, with a few exceptions.

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. Objective-C derives its syntax from both C and Smalltalk: syntax that involves preprocessing, expressions, office declarations, and function calls is inherited from C, while the syntax for object-oriented features was originally taken from Smalltalk.

In addition to C++ and Objective-C, Ch, Cilk, and Unified Parallel C are nearly supersets of C.

Notes [edit]

^ The original case lawmaking will compile on nigh modern compilers that are not in strict standard compliance mode, but information technology does not fully suit to the requirements of either C89 or C99. In fact, C99 requires that a diagnostic message be produced.
^ The principal role actually has ii arguments, int argc and char *argv[], respectively, which tin can be used to handle command line arguments. The ISO C standard (section 5.1.two.two.1) requires both forms of main to be supported, which is special treatment not afforded to whatsoever other office.

References [edit]

^ ^a ^b Kernighan, Brian Due west.; Ritchie, Dennis M. (February 1978). The C Programming Language (1st ed.). Englewood Cliffs, NJ: Prentice Hall. ISBN978-0-13-110163-0.
^ Ritchie (1993): "Thompson had made a brief try to produce a organization coded in an early on version of C—before structures—in 1972, simply gave up the effort."
^ Fruderica (December 13, 2020). "History of C". The cppreference.com. Archived from the original on October 24, 2020. Retrieved October 24, 2020.
^ Ritchie (1993): "The scheme of blazon composition adopted by C owes considerable debt to Algol 68, although it did not, possibly, emerge in a grade that Algol's adherents would approve of."
^ ^a ^b "Verilog HDL (and C)" (PDF). The Research Schoolhouse of Information science at the Australian National University. June iii, 2010. Archived from the original (PDF) on November vi, 2013. Retrieved August nineteen, 2013. 1980s: ; Verilog first introduced ; Verilog inspired past the C programming language
^ ^a ^b ^c ^d ^e ^f Ritchie (1993)
^ "Programming Language Popularity". 2009. Archived from the original on Jan 16, 2009. Retrieved Jan 16, 2009.
^ "TIOBE Programming Community Index". 2009. Archived from the original on May 4, 2009. Retrieved May half-dozen, 2009.
^ ^a ^b "History of C". en.cppreference.com. Archived from the original on May 29, 2018. Retrieved May 28, 2018.
^ "TIOBE Index for October 2021". Retrieved Oct 7, 2021.
^ Ritchie, Dennis. "BCPL to B to C". Archived from the original on December 12, 2019. Retrieved September ten, 2019.
^ ^a ^b ^c ^d ^eastward Jensen, Richard (Dec nine, 2020). ""A damn stupid thing to do"—the origins of C". Ars Technica . Retrieved March 28, 2022.
^ ^a ^b Johnson, S. C.; Ritchie, D. Grand. (1978). "Portability of C Programs and the UNIX Organization". Bell System Tech. J. 57 (6): 2021–2048. CiteSeerX10.1.ane.138.35. doi:x.1002/j.1538-7305.1978.tb02141.x. S2CID 17510065. (Note: The PDF is an OCR browse of the original, and contains a rendering of "IBM 370" every bit "IBM 310".)
^ McIlroy, M. D. (1987). A Inquiry Unix reader: annotated excerpts from the Developer'south Manual, 1971–1986 (PDF) (Technical study). CSTR. Bell Labs. p. 10. 139. Archived (PDF) from the original on November eleven, 2017. Retrieved February i, 2015.
^ "C manual pages". FreeBSD Miscellaneous Information Manual (FreeBSD thirteen.0 ed.). May 30, 2011. Archived from the original on January 21, 2021. Retrieved January 15, 2021. [1] Archived January 21, 2021, at the Wayback Machine
^ Kernighan, Brian Westward.; Ritchie, Dennis One thousand. (March 1988). The C Programming Language (2nd ed.). Englewood Cliffs, NJ: Prentice Hall. ISBN978-0-xiii-110362-7.
^ Stroustrup, Bjarne (2002). Sibling rivalry: C and C++ (PDF) (Study). AT&T Labs. Archived (PDF) from the original on August 24, 2014. Retrieved Apr 14, 2014.
^ C Integrity. International Organization for Standardization. March 30, 1995. Archived from the original on July 25, 2018. Retrieved July 24, 2018.
^ "JTC1/SC22/WG14 – C". Home page. ISO/IEC. Archived from the original on February 12, 2018. Retrieved June 2, 2011.
^ Andrew Binstock (October 12, 2011). "Interview with Herb Sutter". Dr. Dobbs. Archived from the original on Baronial two, 2013. Retrieved September 7, 2013.
^ "Revised C23 Schedule WG xiv N 2759" (PDF). www.open up-std.org. Archived (PDF) from the original on June 24, 2021. Retrieved October 10, 2021.
^ "TR 18037: Embedded C" (PDF). ISO / IEC. Archived (PDF) from the original on Feb 25, 2021. Retrieved July 26, 2011.
^ Harbison, Samuel P.; Steele, Guy 50. (2002). C: A Reference Manual (fifth ed.). Englewood Cliffs, NJ: Prentice Hall. ISBN978-0-13-089592-9. Contains a BNF grammar for C.
^ Kernighan & Ritchie (1996), p. 192.
^ Kernighan & Ritchie (1978), p. three.
^ "ISO/IEC 9899:201x (ISO C11) Committee Draft" (PDF). Archived (PDF) from the original on December 22, 2017. Retrieved September 16, 2011.
^ Kernighan & Ritchie (1996), pp. 192, 259.
^ "ten Mutual Programming Mistakes in C++". Cs.ucr.edu. Archived from the original on October 21, 2008. Retrieved June 26, 2009.
^ Schultz, Thomas (2004). C and the 8051 (3rd ed.). Otsego, MI: PageFree Publishing Inc. p. twenty. ISBN978-1-58961-237-2. Archived from the original on July 29, 2020. Retrieved February 10, 2012.
^ Kernighan & Ritchie (1978), p. 6.
^ ^a ^b ^c ^d ^{due east} ^f ^g Klemens, Ben (2013). 21st Century C. O'Reilly Media. ISBN978-ane-4493-2714-9.
^ Feuer, Alan R.; Gehani, Narain H. (March 1982). "Comparison of the Programming Languages C and Pascal". ACM Computing Surveys. 14 (one): 73–92. doi:10.1145/356869.356872. S2CID 3136859.
^ Kernighan & Ritchie (1996), p. 122.
^ For example, gcc provides _FORTIFY_SOURCE. "Security Features: Compile Time Buffer Checks (FORTIFY_SOURCE)". fedoraproject.org. Archived from the original on January 7, 2007. Retrieved August 5, 2012.
^ เอี่ยมสิริวงศ์, โอภาศ (2016). Programming with C. Bangkok, Thailand: SE-Didactics PUBLIC Visitor LIMITED. pp. 225–230. ISBN978-616-08-2740-4.
^ Raymond, Eric S. (October 11, 1996). The New Hacker's Lexicon (tertiary ed.). MIT Press. p. 432. ISBN978-0-262-68092-9. Archived from the original on November 12, 2012. Retrieved August 5, 2012.
^ "Man Page for lint (freebsd Section 1)". unix.com. May 24, 2001. Retrieved July 15, 2014.
^ Dale, Nell B.; Weems, Chip (2014). Programming and problem solving with C++ (sixth ed.). Burlington, MA: Jones & Bartlett Learning. ISBN978-1449694289. OCLC 894992484.
^ Dr. Dobb's Sourcebook. U.S.A.: Miller Freeman, Inc. November–Dec 1995.
^ "Using C for CGI Programming". linuxjournal.com. March one, 2005. Archived from the original on February 13, 2010. Retrieved January four, 2010.
^ Perkins, Luc (September 17, 2013). "Web development in C: crazy? Or crazy like a play a trick on?". Medium.
^ "#pragma Directive in C/C++". GeeksforGeeks. September 11, 2018. Retrieved April 10, 2022.
^ "Pragmas". Intel . Retrieved April ten, 2022.
^ McMillan, Robert (Baronial 1, 2013). "Is Java Losing Its Mojo?". Wired. Archived from the original on Feb 15, 2017. Retrieved March v, 2017.
^ O'Regan, Gerard (September 24, 2015). Pillars of calculating : a compendium of select, pivotal technology firms. ISBN978-3319214641. OCLC 922324121.
^ Rauchwerger, Lawrence (2004). Languages and compilers for parallel calculating : 16th international workshop, LCPC 2003, College Station, TX, Us, Oct 2-4, 2003 : revised papers. Springer. ISBN978-3540246442. OCLC 57965544.
^ Stroustrup, Bjarne (1993). "A History of C++: 1979−1991" (PDF). Archived (PDF) from the original on February 2, 2019. Retrieved June nine, 2011.

Sources [edit]

Ritchie, Dennis M. (March 1993). "The Development of the C Linguistic communication". ACM SIGPLAN Notices. ACM. 28 (3): 201–208. doi:10.1145/155360.155580.
- Past courtesy of the author, as well at Ritchie, Dennis M. "Chistory". world wide web.bell-labs.com . Retrieved March 29, 2022.
Ritchie, Dennis M. (1993). "The Development of the C Language". The 2nd ACM SIGPLAN Conference on History of Programming Languages (HOPL-Ii). ACM. pp. 201–208. doi:10.1145/154766.155580. ISBN0-89791-570-4 . Retrieved November 4, 2014.
Kernighan, Brian Due west.; Ritchie, Dennis Thousand. (1996). The C Programming Language (2nd ed.). Prentice Hall. ISBNseven-302-02412-10.

External links [edit]

ISO C Working Grouping official website
- ISO/IEC 9899, publicly available official C documents, including the C99 Rationale
- "C99 with Technical corrigenda TC1, TC2, and TC3 included" (PDF). (three.61 MB)
comp.lang.c Frequently Asked Questions
A History of C, by Dennis Ritchie

harrisonharstin.blogspot.com

Source: https://en.wikipedia.org/wiki/C_%28programming_language%29