The C programming language (often, just "C") is a general-purpose, procedural, imperative computer programming language developed in the early 1970s by Dennis Ritchie for use on the Unix operating system. It has since spread to many other operating systems, and is now one of the most widely used programming languages. C has also had a great influence on most other popular languages, especially C++ which was originally designed as an enhancement to C. It is distinguished for the efficiency of the code it produces, and is the most commonly used programming language for writing system software, though it is also widely used for writing applications. Though not originally designed as a language for teaching, and despite its somewhat unforgiving character, C is commonly used in computer science education, in part because the language is so pervasive. Note that C# is a very different programming language.

Philosophy

In part due to the language's low level and modest feature set, C compilers can be developed comparatively easily. The language has therefore become available on a very wide range of platforms (probably more than for any other programming language in existence). Furthermore, despite its low-level nature, the language was designed to enable (and to encourage) machine-independent programming. A standards-compliant and portably written C program can therefore be compiled for a very wide variety of computer platforms and operating systems with minimal change to its source code.

C was originally developed (along with the Unix operating system with which it has long been associated) by programmers and for programmers, with few users other than its own designers in mind. Nevertheless, it has achieved very widespread popularity, finding application in contexts far removed from its roots as a language for systems-programming.

As an Algol-based language, C has the following characteristics:

• A procedural programming paradigm, with facilities for structured programming
• Lexical variable scope and recursion
• A type system which prevents many operations that are not meaningful
• Function parameters which are passed primarily by value (pass-by-reference is achieved in C by explicitly passing pointer values)
• Heterogenous aggregate data types (struct in C) which allow related data elements to be combined and manipulated as a group
• A relatively small set of reserved keywords

C also has the following specific properties:

• Low-level access to computer memory via machine addresses and pointers
• Function pointers allow for a rudimentary form of closures and runtime polymorphism
• A standardized C preprocessor for macro definition, source code file inclusion, conditional compilation, etc.
• A simple, small core language, with functionality such as mathematical functions and file handling provided by library routines
• C (and partially B) was the language that orginally discarded well established operators such as and, or and = (for equality test).

As a systems implementation language, C lacks features found in other languages:

• No non-scalar operations such as copying of arrays or strings (old versions of C did not even copy structs automatically).
• No automatic garbage collection
• No bounds checking of arrays (expensive in languages with only scalar operations)
• No semi-dynamic (i.e. stacked, runtime-sized) arrays until the C99 standard (despite not requiring garbage collection).
• No syntax for ranges, such as the A..B notation used in both newer and older languages (does not fit scalar-only semantics well).
• No nested functions, though the GCC compiler provides this feature as an extension
• No closures or functions as parameters, only machine-level function pointers
• No generators or coroutines; intra-thread control flow consists of nested function calls, barring the (somewhat arcane) use of the longjmp or setcontext library functions
• No exception handling; standard library functions signify error conditions with the global errno variable
• Very rudimentary support for modular programming; a cumbersome compilation model dependent on operating system-specific tools.
• No compile-time polymorphism in the form of function or operator overloading; only rudimentary support for generic programming
• No support for object-oriented programming, although C++ was originally implemented as a preprocessor that translated C++ into C; there are libraries offering object systems for C, and many object-oriented languages are themselves written in C
• No native support for multithreading and networking, though these facilities are provided by popular libraries

Although the list of built-in features C lacks is long, this has contributed significantly to its acceptance, as new C compilers can be developed quickly for new platforms. The relatively low-level nature of the language affords the programmer close control over what the program is doing, while allowing solutions that can be specially tailored and aggressively optimized for a particular platform. This allows the code to run efficiently on very limited hardware, such as mass-produced consumer embedded systems, which today are as capable as the first machines used to implement C. Often, only hand-tuned assembly language code runs faster, although advances in compiler technology have gradually narrowed this gap.

In some cases, a missing feature can be approximated within C. For example, the original implementation of C++ consisted of a preprocessor that translated the C++ syntax into C source code. Most object oriented functions include a special "this" pointer, which refers to the current object. By passing this pointer as a function argument in C, the same functionality can be performed in C. For example, in C++ one might write: stack->push(val); while in C, one would write: push(stack,val); where the stack argument of C is a pointer to a struct which is equivalent to the this pointer of C++, which is a pointer to an object.

History

Early developments

There are many legends as to the origin of C and the closely related Unix operating system, including:

• The development of C was the result of programmers' desire to play Space Travel. They had been playing it on their company's mainframe, but as it was underpowered and had to support about 100 users, Thompson and Ritchie found they did not have sufficient control over the spaceship to avoid collisions with the wandering space rocks. This led to the decision to port the game to an idle PDP-7 in the office. As this machine lacked an operating system, the two set out to develop one, based on several ideas from colleagues. Eventually it was decided to port the operating system to the office's PDP-11, but faced with the daunting task of translating a large body of custom-written assembly language code, the programmers began considering using a portable, high-level language so that the OS could be ported easily from one computer to another. They looked at using B, but it lacked functionality to take advantage of some of the PDP-11's advanced features. This led to the development of an early version of the C programming language.
• The justification for obtaining the original computer to be used in developing the Unix operating system was to create a system to automate the filing of patents. The original version of the Unix system was developed in assembly language. Later, the entire operating system was rewritten in C, an unprecedented move at a time when nearly all operating systems were written in assembly.

By 1973, the C language had become powerful enough that most of the Unix kernel, originally written in PDP-11/20 assembly language, was rewritten in C. This was one of the first operating system kernels implemented in a language other than assembly. (Earlier instances include the Multics system (written in PL/I), and MCP (Master Control Program) for Burroughs B5000 written in ALGOL in 1961.)

K&R C

K&R introduced the following features to the language:

• struct data types
• long int data type
• unsigned int data type
• The =+ operator was changed to += to remove the semantic ambiguity created by the construct i=+10, which could be interpreted as either i =+ 10 or i = +10

K&R C is often considered the most basic part of the language that a C compiler must support. For many years, even after the introduction of ANSI C, it was considered the "lowest common denominator" to which C programmers restricted themselves when maximum portability was desired, since not all compilers were updated to fully support ANSI C, and because with care, K&R C code can be written to be legal ANSI C as well.

In these early versions of C, only functions that returned a non-integer value needed to be declared if used before the function definition. A function used without any previous declaration was assumed to return an integer.

Example call requiring previous declaration:

long int SomeFunction();
int CallingFunction()
{
    long int ret;
    ret = SomeFunction();
}

Example call not requiring previous declaration:

int CallingFunction()
{
    int ret;
    ret = SomeOtherFunction();
}
int SomeOtherFunction()
{
    return 0;
}

Since the K&R prototype did not include any information about function arguments, function parameter type checks were not performed, although some compilers would issue a warning message if a function was called with the wrong number of arguments.

In the years following the publication of K&R C, several "unofficial" features were added to the language, supported by compilers from AT&T and some other vendors. These included:

• void functions and void * data type
• Functions returning struct or union types (rather than pointers)
• Assignment for struct data types
• const qualifier to make an object read-only
• A standard library incorporating most of the functionality implemented by various vendors
• Enumerated types

ANSI C and ISO C

In 1983, the American National Standards Institute (ANSI) formed a committee, X3J11, to establish a standard specification of C. After a long and arduous process, the standard was completed in 1989 and ratified as ANSI X3.159-1989 "Programming Language C." This version of the language is often referred to as ANSI C, or sometimes C89 (to distinguish it from C99).

In 1990, the ANSI C standard (with a few minor modifications) was adopted by the International Organization for Standardization (ISO) as ISO/IEC 9899:1990. This version is sometimes called C90. Therefore, the terms "C89" and "C90" refer to essentially the same language.

One of the aims of the ANSI C standardization process was to produce a superset of K&R C, incorporating many of the unofficial features subsequently introduced. However, the standards committee also included several new features, such as function prototypes (borrowed from C++), and a more capable preprocessor. The syntax for parameter declarations was also changed to reflect the C++ style:

int main(argc, argv)
    int argc;
    char **argv;
{
...
}

became

int main(int argc, char *argv*)
{
...
}

ANSI C is now supported by almost all the widely used C compilers. Most of the C code being written nowadays is based on ANSI C. Any program written only in standard C and without any hardware dependent assumptions is virtually guaranteed to run correctly on any platform with a conforming C implementation. Without such precautions, most programs may compile only on a certain platform or with a particular compiler, due, for example, to the use of non-standard libraries, such as GUI libraries, or to the reliance on compiler- or platform-specific attributes such as the exact size of certain data types and byte endianness.

To mitigate the differences between K&R C and the ANSI C standard, the __STDC__ macro can be used to split code into ANSI and K&R sections.

if __STDC__
extern int getopt(int,char * const *,const char *);
else
extern int getopt();
endif

Some suggest using "#if __STDC__" as above rather than "#ifdef __STDC__" because some compilers set __STDC__ to zero to indicate non-ANSI compliance.

C99

Note: C99 is also the name of a C compiler for the Texas Instruments TI-99/4A home computer. Aside from being a C compiler, it is otherwise unrelated.

After the ANSI standardization process, the C language specification remained relatively static for some time, whereas C++ continued to evolve. (Normative Amendment 1 created a new version of the C language in 1995, but this version is rarely acknowledged.) However, the standard underwent revision in the late 1990s, leading to the publication of ISO 9899:1999 in 1999. This standard is commonly referred to as "C99." It was adopted as an ANSI standard in March 2000.

C99 introduced several new features, many of which had already been implemented as extensions in several compilers:

• Inline functions
• Variables can be declared anywhere (as in C++), rather than only after another declaration or the start of a compound statement
• Several new data types, including long long int (to reduce the pain of the looming 32-bit to 64-bit transition), an explicit boolean data type, fixed-width integer types, and a complex type to represent complex numbers
• Variable-length arrays
• Support for one-line comments beginning with //, as in BCPL or C++
• New library functions, especially replacements for buffer overflow prone functions, such as snprintf()
• New header files, such as stdint.h
• Support for sparse initializers
• Support for variadic macros, or macros of variable arity

C99 is stricter in some ways than previous versions; for example it is (generally) illegal for pointers of different types to reference the same memory location (aliasing). This allows improved optimisation but can break older programs.

GCC and several other C compilers now support most of the new features of C99. However, there has been less support from vendors such as Microsoft and Borland that have been mainly focused on C++, since C++ provides similar functionality in often incompatible ways (e.g., the complex template class). Microsoft's Brandon Bray said "In general, we have seen little demand for many C99 features. Some features have more demand than others, and we will consider them in future releases provided they are compatible with C++." ^*

Even GCC with its extensive C99 support still does not approach a completely compliant implementation; several key features are missing or don't work correctly.^*

Usage

C is used as an intermediate language by some higher-level languages. This is implemented in one of two ways, as languages which:

• Can output object code, machine code, or another representation (e.g., bytecodes), and C source code. Examples: some Lisp dialects, Squeak's C-subset Slang.
• Do not output object code, machine code, or another representation, but output C source code only. Examples: Eiffel, Sather; Esterel.

C source code is then input to a C compiler, which then outputs finished object or machine code. This is done to gain portability and optimization. C compilers exist for nearly all processors and operating systems, and most C compilers output well optimized object or machine code. Thus, any language that outputs C source code suddenly becomes very portable, and able to yield optimized object or machine code.

Unfortunately, C is designed as a programming language, not as a compiler target language, and is thus less than ideal for use as an intermediate language. This has led to development of C-based intermediate languages such as C--.

Syntax

Main article: C syntax

Unlike languages such as FORTRAN 77, C source code is free-form, allowing programmers to use arbitrary whitespace in formatting their code, rather than having to lay out their code according to certain column-based restrictions. Comments can be included either between the delimiters /* and */, or (in C99) following // until the end of the line.

Each source file contains declarations and function definitions. Function definitions, in turn, contain declarations and statements. Declarations either define new types using keywords such as struct, union, and enum, or assign types to and perhaps reserve storage for new variables, usually by writing the type followed by the variable name. Keywords such as char and int, as well as the pointer-to symbol *, specify built-in types. Sections of code are enclosed in braces ({ and }) to indicate the extent to which declarations and control structures apply.

As an imperative language, C depends on statements to do most of the work. Most statements are expression statements which simply cause an expression to be evaluated — and, in the process, cause variables to receive new values or values to be printed. Control-flow statements are also available for conditional or iterative execution, constructed with reserved keywords such as if, else, switch, do, while, and for. Arbitrary jumps are possible with goto. A variety of built-in operators perform primitive arithmetic, Boolean logical, comparative, bitwise logical, and array indexing operations and assignment. Expressions can also invoke functions, including a large number of standard library functions, for performing many common tasks.

"hello, world" example

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

The above program will compile correctly on most modern compilers that are not in compliance mode. However, it produces several warning messages when compiled with a compiler that conforms to the ANSI C standard. Additionally, the code will not compile if the compiler strictly conforms to the C99 standard, as a return value of type int will no longer be assumed if the source code has not specified the return type. Even if it compiles, the resulting program will return an undefined exit status to the environment. These problems can be eliminated with a few minor modifications to the original program:

#include 
int main(void)
{
    printf("hello, world\n");
    return 0;
}

What follows is a line-by-line analysis of the above program:

#include 

int main(void)

{

    printf("hello, world\n");

    return 0;

}

If the above code were compiled and executed, it would do the following:

• Print the string "hello, world" onto the standard output device (typically but not always a terminal),
• Move the current position indicator to the beginning of the next line, then
• Return an exit status of zero to the calling process (such as a command shell or script)

Data structures

C is often used in low-level systems programming, where "escapes" from the type system may be necessary. The compiler attempts to ensure type correctness of most expressions, but the programmer can override the checks in various ways, either by using a typecast to explicitly convert a value from one type to another, or by using pointers or unions to reinterpret the underlying bits of a value in some other way. (The use of typecasts obviously sacrifices some of the safety normally provided by the type system.)

Pointers

A null pointer is a pointer value that points to no valid location (its internal value is usually zero). (Dereferencing a null pointer is therefore meaningless, typically resulting in a runtime error.) Null pointers are useful for indicating special cases such as the next pointer in the final node of a linked list, or as an error code from functions that return pointers. Pointers to type void also exist, and point to objects of unknown type. A void pointer is therefore used as a "generic pointer" (see also generic programming). Since the size and type of the pointed-to object is not known, void pointers cannot be dereferenced, nor is pointer arithmetic on them possible, although they can easily be (and in fact implicitly are) converted to and from any other object pointer type.

Arrays

Traditionally, array types in C were always one-dimensional and of a fixed, static size specified at compile time. (The latest "C99" standard does allow some forms of variable-length arrays.) However, it is also perfectly straightforward to allocate a block of memory (of arbitrary size) at run-time using the standard library and treat it as an array. C's unification of arrays and pointers (see below) means that true arrays and these dynamically-allocated, simulated arrays are virtually interchangeable. However, since arrays are always accessed (in effect) via pointers, array accesses are typically not checked against the underlying array size, although the compiler may provide some level of bounds checking as an option. Array bounds violations are therefore possible and rather common (see also the "Criticism" section below), and can lead to the usual sorts of repercussions: illegal memory accesses, corruption of data, run-time exceptions, etc.

C does not have a special provision for declaring multidimensional arrays, but rather relies on recursion within the type system to declare arrays of arrays, which effectively accomplishes the same thing. The index values of the resulting "multidimensional array" can be thought of as increasing in row-major order. There are provisions for accessing the array as a whole, or only particular elements of the array. However, because of the recursive nature of the type system, sub-array access is limited to row-by-row access.

Array–pointer interchangeability

x* = 1;
(x + i) = 1;
(i + x) = 1;
i* = 1; /* strange, but correct */