C# Upload Image to Web Service From Console Application

General-purpose programming language

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

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

Typing discipline	Static, weak, manifest, nominal
OS	Cantankerous-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++Architect, Microsoft Visual C++, Watcom C
Dialects
Whirlwind, Unified Parallel C, Split-C, Cilk, C*
Influenced by
B (BCPL, CPL), ALGOL 68,^[4] assembly, PL/I, FORTRAN
Influenced
Numerous: AMPL, AWK, csh, C++, C--, C#, Objective-C, D, Become, Java, JavaScript, JS++, Julia, Limbo, LPC, Perl, PHP, Thruway, Processing, Python, Rust, Seed7, Vala, Verilog (HDL),^[five] Nim, Zig
C Programming at Wikibooks

C (, as in the alphabetic character c) is a general-purpose calculator programming language. It was created in the 1970s and remains very widely used and influential. By blueprint, C's 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 computer architectures that range from the largest supercomputers to the smallest microcontrollers and embedded systems.

A successor to the programming linguistic communication B, C was originally developed at Bell Labs by Dennis Ritchie betwixt 1972 and 1973 to construct utilities running on Unix. It was applied to re-implementing the kernel of the Unix operating system.^[6] During the 1980s, C gradually gained popularity. It has get i of the most widely used programming languages,^[7] ^[8] with C compilers available for the nearly all modern computer architectures and operating systems. C has been standardized by ANSI since 1989 (ANSI C) and past the International Organization for Standardization (ISO).

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

Since 2000, C has consistently ranked among the pinnacle two languages in the TIOBE index, a measure of the popularity of programming languages.^[10]

Overview [edit]

C is an imperative, procedural linguistic communication in the ALGOL tradition. It has a static blazon organization. In C, all executable code is independent within subroutines (also called "functions", though not in the sense of functional programming). Function parameters are passed by value, although arrays are passed every bit pointers, i.east. the accost of the commencement item in the array. Pass-by-reference is false in C past explicitly passing pointers to the affair beingness referenced.

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

The C linguistic communication also exhibits the following characteristics:

The language has a small, stock-still number of keywords, including a full set of control flow primitives: if/else, for, do/while, while, and switch. User-defined names are non distinguished from keywords past whatever kind of sigil.
It has a big number of arithmetics, bitwise, and logic operators: +,+=,++,&,||, etc.
More than i assignment may be performed in a single statement.
Functions:
- Role return values can be ignored, when not needed.
- Function and data pointers allow ad hoc run-fourth dimension polymorphism.
- Functions may not exist defined within the lexical scope of other functions.
- Variables may be defined within a function, with telescopic.
- A part may phone call itself, then recursion is supported.
Data typing is static, but weakly enforced; all data has a type, but implicit conversions are possible.
User-defined (typedef) and chemical compound types are possible.
- Heterogeneous aggregate data types (struct) allow related data elements to be accessed and assigned equally a unit.
- Union is a construction with overlapping members; just the last fellow member stored is valid.
- Array indexing is a secondary note, defined in terms of pointer arithmetic. Unlike structs, arrays are not offset-class objects: they cannot be assigned or compared using single congenital-in operators. In that location is no "array" keyword in use or definition; instead, foursquare brackets indicate arrays syntactically, for example calendar month[11].
- Enumerated types are possible with the enum keyword. They are freely interconvertible with integers.
- Strings are not a singled-out information type, but are conventionally implemented as null-terminated character arrays.
Depression-level access to figurer retentiveness is possible past converting motorcar addresses to pointers.
Procedures (subroutines non returning values) are a special case of function, with an untyped return type void.
Memory tin can be allocated to a program with calls to library routines.
A preprocessor performs macro definition, source code file inclusion, and conditional 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 every bit I/O, string manipulation, and mathematical functions are consistently delegated to library routines.
The generated lawmaking after compilation has relatively straightforward needs on the underlying platform, which makes information technology suitable for creating operating systems and for employ in embedded systems.

While C does not include certain features establish in other languages (such every bit object orientation and garbage collection), these tin can be implemented or emulated, ofttimes through the use of external libraries (e.thousand., the GLib Object Organisation or the Boehm garbage collector).

Relations to other languages [edit]

Many later languages take borrowed straight or indirectly from C, including C++, C#, Unix's C crush, D, Go, Java, JavaScript (including transpilers), Julia, Limbo, LPC, Objective-C, Perl, PHP, Python, Cerise, Rust, Swift, Verilog and SystemVerilog (hardware clarification languages).^[5] These languages take drawn many of their command structures and other basic features from C. Most of them (Python being a dramatic exception) also express highly similar syntax to C, and they tend to combine the recognizable expression and statement syntax of C with underlying type systems, data models, and semantics that tin can be radically different.

History [edit]

Early developments [edit]

Timeline of language development
Twelvemonth	C Standard^[9]
1972	Nascence
1978	G&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 evolution of the Unix operating organization, originally implemented in associates linguistic communication on a PDP-7 by Dennis Ritchie and Ken Thompson, incorporating several ideas from colleagues. Eventually, they decided to port the operating organisation to a PDP-xi. The original PDP-11 version of Unix was also adult in associates linguistic communication.^[6]

B [edit]

Thompson desired a programming language to brand utilities for the new platform. At first, he tried to brand a Fortran compiler, but soon gave up the idea. Instead, he created a cutting-down version of the recently developed BCPL systems programming language. The official description of BCPL was not available at the time,^[eleven] and Thompson modified the syntax to be less wordy, and similar to a simplified ALGOL known every bit SMALGOL.^[12] The result was what Thompson called B.^[6] He described B as "BCPL semantics with a lot of SMALGOL syntax".^[12] Like BCPL, B had a bootstrapping compiler to facilitate porting to new machines.^[12] However, few utilities were ultimately written in B because information technology was too slow, and could not take reward of PDP-11 features such as byte addressability.

New B and start C release [edit]

In 1971, Ritchie started to amend B, to utilise the features of the more-powerful PDP-11. A significant add-on was a character type. He called this New B.^[12] Thompson started to use NB to write the Unix kernel, and his requirements shaped the direction of the language development.^[12] ^[thirteen] Through to 1972, richer types were added to the NB language: NB had arrays of int and char; but 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 language was renamed to C. ^[6]

The C compiler and some utilities made with it were included in Version 2 Unix.^[14]

Structures and the Unix kernel re-write [edit]

At Version 4 Unix, released in November 1973, the Unix kernel was extensively re-implemented in C.^[6] Past this time, the C language had acquired some powerful features such equally 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 available in BCPL and PL/I. Its original version provided merely included files and uncomplicated string replacements: #include and #define of parameterless macros. Soon later on that, it was extended, generally by Mike Lesk and then by John Reiser, to incorporate macros with arguments and provisional compilation.^[six]

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

K&R C [edit]

In 1978, Brian Kernighan and Dennis Ritchie published the get-go edition of The C Programming Language.^[ane] This volume, known to C programmers as K&R, served for many years as an breezy specification of the language. The version of C that it describes is normally referred to equally "1000&R C". As this was released in 1978, it is also referred to as C78.^[15] The second edition of the book^[16] covers the afterwards ANSI C standard, described below.

K&R introduced several linguistic communication features:

Standard I/O library
long int information blazon
unsigned int information 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 =- x (decrement i by x) instead of the possibly intended i = -10 (let i exist −10).

Even afterwards 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 notwithstanding in use, and considering carefully written K&R C code can exist legal Standard C every bit well.

In early versions of C, simply functions that return types other than int must be declared if used before the function definition; functions used without prior declaration were presumed to render blazon int.

For instance:

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

The int type specifiers which are commented out could be omitted in K&R C, merely are required in later standards.

Since K&R function declarations did not include any information nigh role arguments, function parameter blazon checks were not performed, although some compilers would issue a warning message if a local function was called with the wrong number of arguments, or if multiple calls to an external office used dissimilar numbers or types of arguments. Separate tools such every bit Unix'southward lint utility were developed that (among other things) could check for consistency of role use across multiple source files.

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

void functions (i.e., functions with no return value)
functions returning struct or matrimony types (rather than pointers)
assignment for struct information types
enumerated types

The big number of extensions and lack of understanding on a standard library, together with the language popularity and the fact that not even the Unix compilers precisely implemented the K&R specification, led to the necessity of standardization.^{[ 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 Institute (ANSI) formed a committee, X3J11, to establish a standard specification of C. X3J11 based the C standard on the Unix implementation; notwithstanding, the non-portable portion of the Unix C library was handed off to the IEEE working grouping 1003 to become the basis for the 1988 POSIX standard. In 1989, the C standard was ratified as ANSI X3.159-1989 "Programming Language C". This version of the language is often referred to as ANSI C, Standard C, or sometimes C89.

In 1990, the ANSI C standard (with formatting changes) was adopted past the International System for Standardization (ISO) as ISO/IEC 9899:1990, which is sometimes called C90. Therefore, the terms "C89" and "C90" refer to the same programming linguistic communication.

ANSI, like other national standards bodies, no longer develops the C standard independently, just defers to the international C standard, maintained by the working group ISO/IEC JTC1/SC22/WG14. National adoption of an update to the international standard typically occurs within a twelvemonth 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 afterwards introduced unofficial features. The standards committee besides included several additional features such equally function 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 style used in C++, the K&R interface continued to be permitted, for compatibility with existing source code.

C89 is supported by current C compilers, and about modern C lawmaking is based on it. Any plan written only in Standard C and without whatsoever hardware-dependent assumptions volition run correctly on any platform with a conforming C implementation, inside its resource limits. Without such precautions, programs may compile but on a certain platform or with a particular compiler, due, for case, to the use of non-standard libraries, such equally GUI libraries, or to a reliance on compiler- or platform-specific attributes such equally the exact size of data types and byte endianness.

In cases where code must be compilable by either standard-conforming or Chiliad&R C-based compilers, the __STDC__ macro tin be used to divide the lawmaking into Standard and One thousand&R sections to foreclose the use on a Thou&R C-based compiler of features bachelor only in Standard C.

After the ANSI/ISO standardization process, the C language specification remained relatively static for several years. In 1995, Normative Subpoena ane to the 1990 C standard (ISO/IEC 9899/AMD1:1995, known informally equally C95) was published, to right some details and to add more extensive support for international grapheme 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 commonly referred to every bit "C99". It has since been amended three times by Technical Corrigenda.^[19]

C99 introduced several new features, including inline functions, several new data types (including long long int and a complex blazon to represent complex numbers), variable-length arrays and flexible array members, improved support for IEEE 754 floating signal, support for variadic macros (macros of variable arity), and support for one-line comments beginning with //, every bit in BCPL or C++. Many of these had already been implemented as extensions in several C compilers.

C99 is for the nigh part astern compatible with C90, but is stricter in some ways; in detail, a declaration that lacks a type specifier no longer has int implicitly assumed. A standard macro __STDC_VERSION__ is divers with value 199901L to indicate that C99 support is bachelor. GCC, Solaris Studio, and other C compilers now support many or all of the new features of C99. The C compiler in Microsoft Visual C++, withal, implements the C89 standard and those parts of C99 that are required for compatibility with C++11.^[twenty] ^{[ needs update ]}

In addition, support for Unicode identifiers (variable / part names) in the course of escaped characters (e.g. \U0001f431) is now required. Support for raw Unicode names is optional.

C11 [edit]

In 2007, piece of 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 type generic macros, anonymous structures, improved Unicode support, atomic operations, multi-threading, and premises-checked functions. It also makes some portions of the existing C99 library optional, and improves compatibility with C++. The standard macro __STDC_VERSION__ is divers as 201112L to signal that C11 support is available.

C17 [edit]

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

C2x [edit]

C2x is an informal proper name for the next (after C17) major C linguistic communication standard revision. It is expected to be voted on in 2023 and would therefore be chosen C23.^[21] ^{[ better source needed ]}

Embedded C [edit]

Historically, embedded C programming requires nonstandard extensions to the C language in lodge to support exotic features such as fixed-point arithmetic, multiple singled-out retentiveness banks, and basic I/O operations.

In 2008, the C Standards Committee published a technical written report extending the C language^[22] to address these issues by providing a common standard for all implementations to adhere to. It includes a number of features non available in normal C, such equally fixed-point arithmetic, named address spaces, and basic I/O hardware addressing.

Syntax [edit]

C has a formal grammer specified by the C standard.^[23] Line endings are generally non significant in C; notwithstanding, line boundaries do have significance during the preprocessing phase. Comments may appear either between the delimiters /* and */, or (since C99) following // until the end of the line. Comments delimited past /* and */ practice not nest, and these sequences of characters are non interpreted equally comment delimiters if they appear within string or grapheme literals.^[24]

C source files contain declarations and office definitions. Function definitions, in turn, incorporate declarations and statements. Declarations either define new types using keywords such as struct, union, and enum, or assign types to and mayhap reserve storage for new variables, usually by writing the type followed by the variable proper noun. Keywords such as char and int specify built-in types. Sections of code are enclosed in braces ({ and }, sometimes called "curly brackets") to limit the telescopic of declarations and to act as a unmarried statement for command structures.

As an imperative language, C uses statements to specify actions. The most common statement is an expression statement, consisting of an expression to be evaluated, followed past a semicolon; every bit a side effect of the evaluation, functions may be called and variables may be assigned new values. To modify the normal sequential execution of statements, C provides several control-catamenia statements identified past reserved keywords. Structured programming is supported past if … [else] conditional execution and past practice … while, while, and for iterative execution (looping). The for argument has separate initialization, testing, and reinitialization expressions, any or all of which tin be omitted. intermission and continue tin can exist used to leave the innermost enclosing loop argument or skip to its reinitialization. In that location is also a not-structured goto statement which branches directly to the designated label within the part. switch selects a instance to be executed based on the value of an integer expression.

Expressions can use a variety of built-in operators and may contain function calls. The order in which arguments to functions and operands to most operators are evaluated is unspecified. The evaluations may even be interleaved. However, all side effects (including storage to variables) volition occur earlier the next "sequence point"; sequence points include the end of each expression argument, and the entry to and render from each function call. Sequence points also occur during evaluation of expressions containing certain operators (&&, ||, ?: and the comma operator). This permits a high degree of object code optimization by the compiler, but requires C programmers to take more intendance to obtain reliable results than is needed for other programming languages.

Kernighan and Ritchie say in the Introduction of The C Programming Linguistic communication: "C, similar any other language, has its blemishes. Some of the operators accept the wrong precedence; some parts of the syntax could be improve."^[25] The C standard did not effort to correct many of these blemishes, because of the affect of such changes on already existing software.

Character set [edit]

The basic C source grapheme set includes the post-obit characters:

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

Newline indicates the finish of a text line; it need not represent to an actual single character, although for convenience C treats it as ane.

Additional multi-byte encoded characters may be used in string 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 feature is not yet widely implemented.

The basic C execution character prepare contains the same characters, forth with representations for alarm, backspace, and carriage render. 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 whatever purposes other than those for which they are predefined:

auto
pause
case
char
const
proceed
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 reserved five more words:

_Bool
_Complex
_Imaginary
inline
restrict

C11 reserved seven more words:^[26]

_Alignas
_Alignof
_Atomic
_Generic
_Noreturn
_Static_assert
_Thread_local

Almost of the recently reserved words brainstorm with an underscore followed past a upper-case letter, because identifiers of that form were previously reserved by the C standard for utilise only by implementations. Since existing programme source code should not have been using these identifiers, information technology would non be afflicted when C implementations started supporting these extensions to the programming linguistic communication. Some standard headers practise define more convenient synonyms for underscored identifiers. The language previously included a reserved give-and-take chosen entry, but this was seldom implemented, and has now been removed as a reserved word.^[27]

Operators [edit]

C supports a rich set up 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: +, -, *, /, %
assignment: =
augmented assignment: +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=
bitwise logic: ~, &, |, ^
bitwise shifts: <<, >>
boolean logic: !, &&, ||
conditional evaluation: ? :
equality testing: ==, !=
calling functions: ( )
increment and decrement: ++, --
fellow member pick: ., ->
object size: sizeof
order relations: <, <=, >, >=
reference and dereference: &, *, [ ]
sequencing: ,
subexpression grouping: ( )
type conversion: (typename)

C uses the operator = (used in mathematics to limited equality) to signal assignment, post-obit the precedent of Fortran and PL/I, but unlike ALGOL and its derivatives. C uses the operator == to examination for equality. The similarity between these two operators (assignment and equality) may outcome in the adventitious utilise of 1 in identify of the other, and in many cases, the mistake does not produce an error message (although some compilers produce warnings). For example, the conditional expression if (a == b + 1) might mistakenly exist written equally if (a = b + 1), which will exist evaluated as true if a is not zippo subsequently the assignment.^[28]

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

"Hello, globe" example [edit]

The "hullo, world" case, which appeared in the commencement edition of G&R, has become the model for an introductory program in nearly programming textbooks. The program prints "howdy, globe" to the standard output, which is normally a terminal or screen brandish.

The original version was:^[30]

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

A standard-conforming "howdy, world" program is:^[a]

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

The beginning line of the program contains a preprocessing directive, indicated by #include. This causes the compiler to replace that line with the entire text of the stdio.h standard header, which contains declarations for standard input and output functions such as printf and scanf. 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 name, every bit opposed to double quotes which typically include local or projection-specific header files.

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

The opening curly brace indicates the kickoff of the definition of the main office.

The next line calls (diverts execution to) a function named printf, which in this case is supplied from a system library. In this call, the printf function is passed (provided with) a unmarried argument, the address of the first grapheme in the string literal "hello, world\n". The string literal is an unnamed array with elements of blazon char, ready up automatically by the compiler with a concluding 0-valued grapheme to mark the finish of the assortment (printf needs to know this). The \north is an escape sequence that C translates to a newline grapheme, which on output signifies the end of the current line. The render value of the printf role is of type int, but it is silently discarded since it is non used. (A more conscientious programme might test the return value to determine whether or non the printf function succeeded.) The semicolon ; terminates the argument.

The closing curly brace indicates the end of the code for the main function. According to the C99 specification and newer, the principal function, different whatsoever other function, will implicitly render 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 equally an exit code indicating successful execution.^[31]

Information types [edit]

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

C is oft used in depression-level systems programming where escapes from the type system may exist necessary. The compiler attempts to ensure type correctness of most expressions, but the programmer can override the checks in various ways, either past using a type cast to explicitly convert a value from one type to another, or by using pointers or unions to reinterpret the underlying $.25 of a data object in some other fashion.

Some notice C's proclamation syntax unintuitive, particularly for role pointers. (Ritchie's idea was to declare identifiers in contexts resembling their utilise: "declaration reflects use".)^[33]

C'due south usual arithmetic conversions allow for efficient code to be generated, but tin sometimes produce unexpected results. For case, a comparison 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 apply of pointers, a type of reference that records the address or location of an object or function in memory. Pointers tin be dereferenced to access data stored at the accost pointed to, or to invoke a pointed-to role. Pointers can be manipulated using assignment or arrow arithmetic. The run-time representation of a pointer value is typically a raw memory address (perhaps augmented by an outset-within-word field), simply since a pointer's type includes the type of the thing pointed to, expressions including pointers tin can be blazon-checked at compile time. Pointer arithmetic is automatically scaled past the size of the pointed-to information type. Pointers are used for many purposes in C. Text strings are commonly manipulated using pointers into arrays of characters. Dynamic retentivity allocation is performed using pointers. Many data types, such as trees, are commonly implemented as dynamically allocated struct objects linked together using pointers. Pointers to functions are useful for passing functions as arguments to higher-gild functions (such every bit qsort or bsearch) or equally callbacks to be invoked by issue handlers.^[31]

A null pointer value explicitly points to no valid location. Dereferencing a cypher pointer value is undefined, often resulting in a division mistake. Null pointer values are useful for indicating special cases such as no "next" pointer in the final node of a linked list, or as an error indication from functions returning pointers. In advisable contexts in source code, such as for assigning to a pointer variable, a null pointer abiding tin be written as 0, with or without explicit casting to a pointer type, or as the NULL macro divers past several standard headers. In provisional contexts, nil pointer values evaluate to simulated, while all other arrow values evaluate to true.

Void pointers (void *) point to objects of unspecified blazon, and can 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 arithmetics on them allowed, although they tin easily be (and in many contexts implicitly are) converted to and from any other object pointer type.^[31]

Devil-may-care utilize of pointers is potentially unsafe. Because they are typically unchecked, a pointer variable can be made to signal to any arbitrary location, which tin can cause undesirable effects. Although properly used pointers bespeak to safe places, they tin can be fabricated to point to dangerous places by using invalid pointer arithmetic; the objects they betoken to may continue to be used later deallocation (dangling pointers); they may be used without having been initialized (wild pointers); or they may be directly assigned an dangerous value using a bandage, union, or through another decadent pointer. In general, C is permissive in allowing manipulation of and conversion between pointer types, although compilers typically provide options for various levels of checking. Some other programming languages address these bug past using more restrictive reference types.

Arrays [edit]

Assortment types in C are traditionally of a fixed, static size specified at compile time. The more recent C99 standard also allows a class of variable-length arrays. Nevertheless, it is also possible to classify a block of memory (of arbitrary size) at run-time, using the standard library'due south malloc function, and treat it as an array.

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

C does not take a special provision for declaring multi-dimensional arrays, but rather relies on recursion inside the type system to declare arrays of arrays, which finer accomplishes the aforementioned affair. The index values of the resulting "multi-dimensional assortment" tin can be thought of as increasing in row-major order. Multi-dimensional arrays are ordinarily used in numerical algorithms (mainly from practical linear algebra) to store matrices. The structure of the C assortment is well suited to this item job. Withal, 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 classify the array with an additional "row vector" of pointers to the columns.) C99 introduced "variable-length arrays" which address this outcome.

The following instance using modern C (C99 or later) shows allocation of a two-dimensional array on the heap and the employ of multi-dimensional array indexing for accesses (which can use bounds-checking on many C compilers):

                        int                                    func            (            int                                    North            ,                                    int                                    M            )                        {                                                bladder                                    (            *            p            )[            N            ][            M            ]                                    =                                    malloc            (            sizeof                                    *            p            );                                                if                                    (            !            p            )                                                return                                    -1            ;                                                for                                    (            int                                    i                                    =                                    0            ;                                    i                                    <                                    N            ;                                    i            ++            )                                                for                                    (            int                                    j                                    =                                    0            ;                                    j                                    <                                    Thousand            ;                                    j            ++            )                                                (            *            p            )[            i            ][            j            ]                                    =                                    i                                    +                                    j            ;                                                print_array            (            N            ,                                    M            ,                                    p            );                                                gratuitous            (            p            );                                                return                                    1            ;                        }

And here is a similar implementation using C99's Car VLA feature:

                        int                                    func            (            int                                    N            ,                                    int                                    M            )                        {                                                // Circumspection: checks should be made to ensure N*M*sizeof(float) does NOT exceed limitations for machine 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                                    <                                    N            ;                                    i            ++            )                                                for                                    (            int                                    j                                    =                                    0            ;                                    j                                    <                                    M            ;                                    j            ++            )                                                p            [            i            ][            j            ]                                    =                                    i                                    +                                    j            ;                                                // no need to gratis(p) since it volition disappear when the office exits, along with the rest of the stack frame                                    render                                    one            ;                        }

Assortment–pointer interchangeability [edit]

The subscript note x[i] (where x designates a pointer) is syntactic carbohydrate for *(ten+i).^[36] Taking advantage of the compiler's knowledge of the pointer type, the address that x + i points to is not the base address (pointed to by 10) incremented past i bytes, merely rather is defined to be the base address incremented by i multiplied past the size of an element that x points to. Thus, x[i] designates the i+oneth element of the assortment.

Furthermore, in near expression contexts (a notable exception is equally operand of sizeof), an expression of array type is automatically converted to a pointer to the array's first chemical element. This implies that an array is never copied as a whole when named as an argument to a role, but rather simply the address of its first chemical element is passed. Therefore, although function calls in C use laissez passer-by-value semantics, arrays are in effect passed past reference.

The total size of an array x tin be determined by applying sizeof to an expression of array type. The size of an element tin exist determined by applying the operator sizeof to any dereferenced element of an assortment A, as in n = sizeof A[0]. This, the number of elements in a declared array A can exist determined every bit sizeof A / sizeof A[0]. Note, that if only a pointer to the starting time element is bachelor every bit it is often the case in C code because of the automated conversion described above, the information about the full type of the array and its length are lost.

Memory management [edit]

One of the near of import functions of a programming linguistic communication is to provide facilities for managing memory and the objects that are stored in retentiveness. C provides three main ways to allocate retentivity for objects:^[31]

Static memory allocation: space for the object is provided in the binary at compile-time; these objects accept an extent (or lifetime) equally long every bit the binary which contains them is loaded into memory.
Automated memory allotment: temporary objects tin can be stored on the stack, and this space is automatically freed and reusable afterward the block in which they are alleged is exited.
Dynamic memory allocation: blocks of memory of arbitrary size can be requested at run-time using library functions such as malloc from a region of retentivity called the heap; these blocks persist until subsequently freed for reuse by calling the library part realloc or gratuitous

These three approaches are appropriate in unlike situations and have various trade-offs. For case, static memory allocation has little resource allotment overhead, automatic resource allotment may involve slightly more than overhead, and dynamic memory resource allotment can potentially have a great deal of overhead for both allocation and deallocation. The persistent nature of static objects is useful for maintaining state information across function calls, automatic resource allotment is like shooting fish in a barrel to apply just stack space is typically much more than limited and transient than either static retention or heap infinite, and dynamic memory resource allotment allows convenient resource allotment of objects whose size is known only at run-time. Nearly C programs make extensive employ of all iii.

Where possible, automatic or static allocation is unremarkably simplest considering the storage is managed past the compiler, freeing the developer of the potentially error-prone chore of manually allocating and releasing storage. Nonetheless, many data structures tin can change in size at runtime, and since static allocations (and automatic allocations earlier C99) must have a fixed 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 instance of this. (See the article on malloc for an example of dynamically allocated arrays.) Dissimilar automatic allocation, which tin can fail at run time with uncontrolled consequences, the dynamic allocation functions return an indication (in the form of a null pointer value) when the required storage cannot be allocated. (Static allocation that is too large is usually detected by the linker or loader, earlier the plan tin can fifty-fifty begin execution.)

Unless otherwise specified, static objects contain zero or nil pointer values upon program startup. Automatically and dynamically allocated objects are initialized only if an initial value is explicitly specified; otherwise they initially take indeterminate values (typically, whatever bit pattern happens to exist present in the storage, which might not even stand for a valid value for that blazon). If the program attempts to access an uninitialized value, the results are undefined. Many modern compilers try to notice and warn about this problem, but both false positives and false negatives can occur.

Heap retentiveness allocation has to be synchronized with its actual usage in any plan to be reused as much equally possible. For example, if the only pointer to a heap memory allocation goes out of telescopic or has its value overwritten before it is deallocated explicitly, then that memory cannot exist recovered for later on reuse and is substantially lost to the program, a phenomenon known as a retention leak. Conversely, it is possible for memory to be freed, but is referenced subsequently, leading to unpredictable results. Typically, the failure symptoms appear in a portion of the programme unrelated to the code that causes the error, making information technology 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 fix 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 by a program, and declarations of special information types and macro symbols used with these functions. In society for a plan to employ a library, information technology must include the library's header file, and the library must be linked with the program, which in many cases requires compiler flags (e.g., -lm, shorthand for "link the math library").^[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, graphic symbol strings, and time values. Several separate standard headers (for example, stdio.h) specify the interfaces for these and other standard library facilities.

Another common set of C library functions are those used by applications specifically targeted for Unix and Unix-like systems, particularly 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 accept been written in C, there are a wide variety of other libraries available. Libraries are often written in C because C compilers generate efficient object code; programmers then create interfaces to the library then that the routines can be used from college-level languages like Java, Perl, and Python.^[31]

File treatment and streams [edit]

File input and output (I/O) is not role of the C linguistic communication itself but instead is handled by libraries (such as the C standard library) and their associated header files (e.g. stdio.h). File handling is by and large implemented through high-level I/O which works through streams. A stream is from this perspective a data menses that is contained of devices, while a file is a concrete device. The high-level I/O is done through the association of a stream to a file. In the C standard library, a buffer (a memory area or queue) is temporarily used to store data earlier information technology's sent to the terminal destination. This reduces the fourth dimension spent waiting for slower devices, for example a difficult drive or solid country drive. Low-level I/O functions are not role of the standard C library^{[ clarification needed ]} but are mostly part of "bare metallic" programming (programming that's independent of whatever operating system such as most embedded programming). With few exceptions, implementations include low-level I/O.

Language tools [edit]

A number of tools have been adult to help C programmers observe and gear up statements with undefined behavior or possibly erroneous expressions, with greater rigor than that provided by the compiler. The tool lint was the showtime such, leading to many others.

Automated source lawmaking checking and auditing are beneficial in any language, and for C many such tools exist, such as Lint. A common exercise is to use Lint to discover questionable lawmaking when a program is first written. Once a plan passes Lint, information technology is so compiled using the C compiler. As well, 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]

At that place are besides compilers, libraries, and operating organization level mechanisms for performing deportment that are not a standard part of C, such as premises checking for arrays, detection of buffer overflow, serialization, dynamic memory tracking, and automated garbage collection.

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

Uses [edit]

The C Programming Language

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

The code generated afterwards compilation doesn't demand many organization features, and can be invoked from some boot code in a straightforward manner - it's simple 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 organisation resources - it's fast to execute.
The language makes it like shooting fish in a barrel to overlay structures onto blocks of binary information, allowing the information to be comprehended, navigated and modified - it tin can write information structures, fifty-fifty file systems.
The language supports a rich set of operators, including bit manipulation, for integer arithmetics and logic, and perchance dissimilar sizes of floating point numbers - information technology can process appropriately-structured data effectively.
Platform hardware can exist accessed with pointers and blazon punning, so system-specific features (due east.1000. Command/Condition Registers, I/O registers) can be configured and used with lawmaking written in C - it interacts well with the platform information technology'due south running on.
Depending on the linker and environment, C code can also call libraries written in assembly language, and may be called from assembly linguistic communication - it interoperates well with other code.
C has a very mature and broad ecosystem, including open source compilers, debuggers and utilities, and is the de-facto standard. Information technology'southward probable the drivers already be in C, or that there is a similar CPU architecture every bit a back-end of a C compiler, then at that place is reduced incentive to choose another linguistic communication.

Historically, C was sometimes used for web development using the Common Gateway Interface (CGI) as a "gateway" for information between the web application, the server, and the browser.^[39] C may take been called over interpreted languages because of its speed, stability, and near-universal availability.^[xl] It is no longer common do for spider web development to be done in C,^[41] and many other web development tools be.

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

C enables programmers to create efficient implementations of algorithms and information structures, considering the layer of abstraction from hardware is thin, and its overhead is low, an of import 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 support 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 every bit an intermediate language by implementations of other languages. This approach may be used for portability or convenience; past using C as 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 support compilation of generated code. However, some of C'due south shortcomings accept 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 ]} Still, such applications can also be written in newer, higher-level languages.

Limitations [edit]

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

The utilise of pointers and the direct manipulation of retentiveness means abuse of memory is possible, perchance due to programmer mistake, or insufficient checking of bad information.
Since the code generated by the compiler contains few checks itself, at that place is a burden on the programmer to consider all possible outcomes, and protect confronting buffer overruns, array premises checking, stack overflows, memory exhaustion, race conditions, thread isolation, etc.
The use of pointers and the run-time manipulation of these means there may be two ways to access the same data (aliasing), which is not determinable at compile time. This means that some optimisations that may be available to other languages are not possible in C. FORTRAN is considered faster.
In that location is limited standardisation in support for low-level variants in generated code, for example: different role calling conventions; different structure packing conventions; dissimilar 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 e.thousand. use __cdecl calling convention. But the directive and options are non consistently supported.^[43]
The language does non directly support object orientation, introspection, run-fourth dimension 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 take been adopted, e.g. MISRA C, in an endeavor to reduce the opportunity for bugs. There are tools that tin can mitigate against some of these drawbacks. Some of these drawbacks have prompted the construction of other languages.

[edit]

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

C has both straight and indirectly influenced many later languages such as C#, D, Go, Java, JavaScript, Limbo, LPC, Perl, PHP, Python, and Unix'south C beat.^[45] The nearly pervasive influence has been syntactical; all of the languages mentioned combine the argument and (more than or less recognizably) expression syntax of C with type systems, data models, and/or large-scale program structures that differ from those of C, sometimes radically.

Several C or near-C interpreters exist, including Ch and CINT, which can also be 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 then compiled with a C compiler.^[46]

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

Objective-C was originally a very "thin" layer on acme 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, function declarations, and function calls is inherited from C, while the syntax for object-oriented features was originally taken from Smalltalk.

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

Notes [edit]

^ The original example code will compile on most modern compilers that are not in strict standard compliance mode, but it does not fully arrange to the requirements of either C89 or C99. In fact, C99 requires that a diagnostic message exist produced.
^ The main function actually has two arguments, int argc and char *argv[], respectively, which can be used to handle command line arguments. The ISO C standard (department v.1.two.2.ane) requires both forms of primary to be supported, which is special treatment not afforded to any other part.

References [edit]

^ ^a ^b Kernighan, Brian W.; 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 attempt to produce a system coded in an early version of C—earlier structures—in 1972, only gave up the effort."
^ Fruderica (Dec xiii, 2020). "History of C". The cppreference.com. Archived from the original on October 24, 2020. Retrieved October 24, 2020.
^ Ritchie (1993): "The scheme of type composition adopted by C owes considerable debt to Algol 68, although it did not, perhaps, emerge in a form that Algol'due south adherents would approve of."
^ ^a ^b "Verilog HDL (and C)" (PDF). The Research School of Computer Science at the Australian National University. June 3, 2010. Archived from the original (PDF) on November 6, 2013. Retrieved August 19, 2013. 1980s: ; Verilog showtime introduced ; Verilog inspired by the C programming linguistic communication
^ ^a ^b ^c ^d ^{due east} ^f Ritchie (1993)
^ "Programming Language Popularity". 2009. Archived from the original on January 16, 2009. Retrieved January xvi, 2009.
^ "TIOBE Programming Customs Alphabetize". 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 Oct 2021". Retrieved Oct seven, 2021.
^ Ritchie, Dennis. "BCPL to B to C". Archived from the original on Dec 12, 2019. Retrieved September ten, 2019.
^ ^a ^b ^c ^d ^e Jensen, Richard (December nine, 2020). ""A damn stupid matter to do"—the origins of C". Ars Technica . Retrieved March 28, 2022.
^ ^a ^b Johnson, Southward. C.; Ritchie, D. M. (1978). "Portability of C Programs and the UNIX System". Bell System Tech. J. 57 (6): 2021–2048. CiteSeerX10.1.1.138.35. doi:10.1002/j.1538-7305.1978.tb02141.x. S2CID 17510065. (Note: The PDF is an OCR scan of the original, and contains a rendering of "IBM 370" as "IBM 310".)
^ McIlroy, M. D. (1987). A Research Unix reader: annotated excerpts from the Programmer'southward Transmission, 1971–1986 (PDF) (Technical study). CSTR. Bell Labs. p. 10. 139. Archived (PDF) from the original on November eleven, 2017. Retrieved February 1, 2015.
^ "C manual pages". FreeBSD Miscellaneous Data Manual (FreeBSD xiii.0 ed.). May thirty, 2011. Archived from the original on January 21, 2021. Retrieved January 15, 2021. [ane] Archived January 21, 2021, at the Wayback Machine
^ Kernighan, Brian W.; Ritchie, Dennis M. (March 1988). The C Programming Language (second ed.). Englewood Cliffs, NJ: Prentice Hall. ISBN978-0-13-110362-7.
^ Stroustrup, Bjarne (2002). Sibling rivalry: C and C++ (PDF) (Report). AT&T Labs. Archived (PDF) from the original on Baronial 24, 2014. Retrieved Apr fourteen, 2014.
^ C Integrity. International Arrangement 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 August ii, 2013. Retrieved September 7, 2013.
^ "Revised C23 Schedule WG fourteen 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 February 25, 2021. Retrieved July 26, 2011.
^ Harbison, Samuel P.; Steele, Guy L. (2002). C: A Reference Manual (5th ed.). Englewood Cliffs, NJ: Prentice Hall. ISBN978-0-13-089592-ix. 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 Dec 22, 2017. Retrieved September 16, 2011.
^ Kernighan & Ritchie (1996), pp. 192, 259.
^ "10 Common Programming Mistakes in C++". Cs.ucr.edu. Archived from the original on Oct 21, 2008. Retrieved June 26, 2009.
^ Schultz, Thomas (2004). C and the 8051 (3rd ed.). Otsego, MI: PageFree Publishing Inc. p. 20. ISBN978-1-58961-237-2. Archived from the original on July 29, 2020. Retrieved Feb 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-1-4493-2714-ix.
^ Feuer, Alan R.; Gehani, Narain H. (March 1982). "Comparison of the Programming Languages C and Pascal". ACM Calculating Surveys. fourteen (1): 73–92. doi:x.1145/356869.356872. S2CID 3136859.
^ Kernighan & Ritchie (1996), p. 122.
^ For instance, 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-EDUCATION PUBLIC COMPANY LIMITED. pp. 225–230. ISBN978-616-08-2740-4.
^ Raymond, Eric S. (October eleven, 1996). The New Hacker'due south Dictionary (3rd ed.). MIT Printing. p. 432. ISBN978-0-262-68092-9. Archived from the original on Nov 12, 2012. Retrieved August 5, 2012.
^ "Man Page for lint (freebsd Section one)". unix.com. May 24, 2001. Retrieved July 15, 2014.
^ Dale, Nell B.; Weems, Flake (2014). Programming and problem solving with C++ (6th ed.). Burlington, MA: Jones & Bartlett Learning. ISBN978-1449694289. OCLC 894992484.
^ Dr. Dobb's Sourcebook. U.S.A.: Miller Freeman, Inc. November–December 1995.
^ "Using C for CGI Programming". linuxjournal.com. March i, 2005. Archived from the original on February thirteen, 2010. Retrieved January 4, 2010.
^ Perkins, Luc (September 17, 2013). "Web development in C: crazy? Or crazy similar a fox?". Medium.
^ "#pragma Directive in C/C++". GeeksforGeeks. September 11, 2018. Retrieved April 10, 2022.
^ "Pragmas". Intel . Retrieved April 10, 2022.
^ McMillan, Robert (August one, 2013). "Is Java Losing Its Mojo?". Wired. Archived from the original on February xv, 2017. Retrieved March 5, 2017.
^ O'Regan, Gerard (September 24, 2015). Pillars of computing : 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, USA, October 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 9, 2011.

Sources [edit]

Ritchie, Dennis M. (March 1993). "The Development of the C Linguistic communication". ACM SIGPLAN Notices. ACM. 28 (iii): 201–208. doi:x.1145/155360.155580.
- By courtesy of the writer, also at Ritchie, Dennis K. "Chistory". world wide web.bell-labs.com . Retrieved March 29, 2022.
Ritchie, Dennis Thou. (1993). "The Development of the C Language". The 2d ACM SIGPLAN Conference on History of Programming Languages (HOPL-II). ACM. pp. 201–208. doi:ten.1145/154766.155580. ISBN0-89791-570-4 . Retrieved November 4, 2014.
Kernighan, Brian W.; Ritchie, Dennis M. (1996). The C Programming Language (second ed.). Prentice Hall. ISBN7-302-02412-X.

Farther reading [edit]

Kernighan, Brian; Ritchie, Dennis (1988). The C Programming Linguistic communication (ii ed.). Prentice Hall. ISBN978-0131103627. (archive)
Plauger, P.J. (1992). The Standard C Library (1 ed.). Prentice Hall. ISBN978-0131315099. (source)
Banahan, One thousand.; Brady, D.; Doran, 1000. (1991). The C Book: Featuring the ANSI C Standard (two ed.). Addison-Wesley. ISBN978-0201544336. (free)
Harbison, Samuel; Steele Jr, Guy (2002). C: A Reference Manual (v ed.). Pearson. ISBN978-0130895929. (archive)
King, K.Northward. (2008). C Programming: A Modern Arroyo (two ed.). Due west. W. Norton. ISBN978-0393979503. (archive)
Griffiths, David; Griffiths, Dawn (2012). Caput Get-go C (one ed.). O'Reilly. ISBN978-1449399917.
Perry, Greg; Miller, Dean (2013). C Programming: Absolute Beginner's Guide (3 ed.). Que. ISBN978-0789751980.
Deitel, Paul; Deitel, Harvey (2015). C: How to Program (eight ed.). Pearson. ISBN978-0133976892.
Gustedt, Jens (2019). Modernistic C (2 ed.). Manning. ISBN978-1617295812. (free)

External links [edit]

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

dockeryshoebethe.blogspot.com

Source: https://en.wikipedia.org/wiki/C_(programming_language)