C (programming language)

C is a programming language designed and first implemented by Dennis Ritchie in the early 1970s for writing the UNIX operating system. C remains the most widely used language for writing system software, and C is also used for writing applications.

Features

The main features of C are:

Focus on the procedural programming paradigm, with facilities for programming in a structured style.
Access to low level hardware via the use of pointers to refer to locations in memory.
Parameters are always passed to functions by value, not by reference.
Lexical variable scoping (but no support for closures or functions defined within functions).
A language definition simple enough to keep the entire language in the programmer's head. This is accomplished by restricting the language to essential syntax and operators, and exporting everything nonessential to a standardized set of library routines.
Use of a preprocessor language, the C preprocessor, for tasks such as defining macros and including multiple source code files.
O(1) performance for all operators.

The functionality of C is guaranteed by the ANSI/ISO C89/90 and C99 standards documents, which explicitly specify when the compiler (or environment) shall issue diagnostics. The documents also specify what behavior one can expect from C code that conforms to the standard.

For example, the following code, according to the standard, produces undefined behavior (specifically, because the parameters passed to the standard strcpy() function should not overlap).


#include <stdio.h>
#include <string.h>

int main (void)
{
    char *s = "Hello World!\n";

    strcpy (s, s+1); /* remove first character from string s --
                        s = s+1;
                        is probably what the programmer wanted */
    return 0;
}

Note: bracing style varies from programmer to programmer and can be the subject of great debate ("religious wars"). See Indent style for more details.

"Undefined behavior" means that the resulting program can do anything, including (accidentally) working as the programmer intended it to, producing incorrect output, crashing horribly every time it is run, crashing only under certain obscure conditions, etc. The canonical expression among experienced C programmers is that "demons may fly out of your nose" (usually abbreviated to "nasal demons")—i.e., anything can happen.

Some compilers do not adhere to either of the standards in their default mode, which leads to many programs being written which will only compile with a certain version of a certain compiler on a certain platform. Any program written only in standard C will compile unchanged on any platform which has a conforming C implementation.

Although C is usually termed a high level language, this is only in comparison to assembly language; it is significantly lower-level than most other programming languages. In particular, it is up to the programmer to manage the contents of computer memory. C provides no facilities for array bounds checking or automatic garbage collection. C has sometimes been termed "portable assembly language".

Manual memory management provides the programmer with greater leeway in tuning the performance of a program, which is particularly important for programs such as device drivers. However, it also makes it easy to accidentally create code with bugs stemming from erroneous memory operations, such as buffer overflows. Tools have been created to help programmers avoid these errors, including libraries for performing array bounds checking and garbage collection, and the lint source code checker. Intentional exploitation of programs written in C containing potential buffer overruns is often used to break computer security, either manually or by viruses and worms.

Some of the perceived shortcomings of C have been addressed by newer programming languages derived from C. The Cyclone programming language has features to guard against erroneous memory operations. C++ and Objective C provide constructs designed to aid object-oriented programming. Java and C# add object-oriented programming constructs as well as a higher level of abstraction, such as automatic memory management.

History

The initial development of C occurred between 1969 and 1973 (according to Ritchie, the most creative period was during 1972). It was called "C" because many features derived from an earlier language named B. Accounts differ regarding the origins of B. It may have derived from an earlier language called BCPL, or from another language called Bon, which may or may not have been named after Ken Thompson's wife Bonnie.

By 1973, the C language had become powerful enough that most of the UNIX kernel was reimplemented in C, perhaps following the examples of the Multics system (implemented in PL/I), Tripos (implemented in BCPL), and possibly others. In 1978, Ritchie and Brian Kernighan published The C Programming Language (usually referred to as K&R, sometimes as "the white book"). For many years, this book served as the specification of the language; even today, it enjoys great popularity as a manual and tutorial.

C became immensely popular outside Bell Labs during the 1980s, and was for a time the dominant language in systems and microcomputer applications programming. It is still the most commonly-used language in systems programming, and is one of the most frequently used programming languages in computer science education. A study of one Linux distribution found that 71% of its 30 million lines of code was C code.

In the late 1980s, Bjarne Stroustrup and others at Bell Labs worked to add object-oriented programming language constructs to C. The language they produced with Cfront was called C++ (thus avoiding the issue of whether the successor to "B" and "C" should be "D" or "P".) C++ is now the language most commonly used for commercial applications on the Microsoft Windows operating system, though C remains more popular in the Unix world.

Versions of C

K&R C

C evolved continuously from its beginnings in Bell Labs. In 1978, the first edition of Kernighan and Ritchie's The C Programming Language was published. It introduced the following features to the existing versions of C:

structure data types
long int data type
unsigned int data type
The =+ operator was changed to +=, and so forth (=+ was confusing the C compiler's lexical analyzer).

For several years, the first edition of The C Programming Language was widely used as a de facto specification of the language. The version of C described in this book is commonly referred to as "K&R C." (The second edition covers the ANSI C standard, described below.)

K&R C is often considered the most basic part of the language that is necessary for a C compiler to support. Since not all of the currently-used compilers have been updated to fully support ANSI C fully, and reasonably well-written K&R C code is also legal ANSI C, K&R C is considered the lowest common denominator that programmers should stick to when maximum portability is desired. For example, the bootstrapping version of the GCC compiler, xgcc, is written in K&R C. This is because many of the platforms supported by GCC did not have an ANSI C compiler when GCC was written, just one supporting K&R C.

However, ANSI C is now supported by almost all the widely used compilers. Most of the C code being written nowadays uses language features that go beyond the original K&R specification.

ANSI C and ISO C

In 1989, C was first officially standardized by ANSI in ANSI X3.159-1989 "Programming Language C". One of the aims of the ANSI C standard process was to produce a superset of K&R C. However, the standards committees also included several new features, more than is normal in programming language standardization.

Some of the new features had been "unofficially" added to the language after the publication of K&R, but before the beginning of the ANSI C process. These included:

void functions and void * data type
functions returning struct or union types
struct field names in a separate name space for each struct type
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
enumerations
the single-precision float type

Several features were added during the standardization process, most notably function prototypes (borrowed from C++), and a more capable preprocessor.

The ANSI C standard, with a few minor modifications, was adopted as ISO standard number ISO 9899. The first ISO edition of this document was published in 1990 (ISO 9899:1990.)

C99

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 ISO 9899:1999, which was published in 1999. This standard is commonly referred to as "C99". It was adopted as an ANSI standard in March 2000.

The new features added in C99 include:

inline functions
freeing of restrictions on the location of variable declarations (as in C++)
the addition of several new data types, including long long int (to reduce the pain of the 32-bit to 64-bit transition looming for much old code with the predicted obsolescence of the x86 architecture), an explicit boolean datatype, and a type representing complex numbers
variable-length arrays
official support for one-line comments beginning with // as in C++ (already supported by many C89 compilers as a nonstandard extension)
several new library functions, including snprintf()
several new header files, including stdint.h

Interest in supporting the new C99 features is mixed. Whereas GCC and several commercial compilers support most of the new features of C99, the compilers maintained by Microsoft and Borland do not, and these two companies do not seem to be interested in adding such support.

"Hello, World!" in C

The following simple application prints out "Hello, World!" to the standard output file (which is usually the screen, but might be a file or some other hardware device). A version of this program appeared for the first time in K&R.


#include <stdio.h>

int main(void)
{
    printf("Hello, World!\n");
    return 0;
}

Anatomy of a C Program

A C program consists of functions and variables. C functions are like the subroutines and functions of Fortran or the procedures and functions of Pascal. The function main() is special in that a C program always begins executing at the beginning of this function. This means that every C program must have a main() function.

The main() function will usually call other functions to help perform its job, such as printf() in the above example. Functions from the standard library are frequently used. Other libraries can provide extra functionality, such as a graphical interface, advanced mathematical operations, or access to platform-specific features. Any nontrivial program will include its own functions written by the programmer.

A function may return a value to the environment which called it. This is usually another C function. The main() function's calling environment is the operating system. Hence, in the "Hello, world!" example above, the operating system receives a value of 0 when the program terminates.

A C function consists of a return type (void if no value is returned), a unique name, a list of parameters in parentheses (void if there are none) and a function body delimited by braces. The syntax of the function body is equivalent to that of a compound statement.

Control structures

Compound statements

Compound statements in C have the form

  { <optional-declaration-list> <optional-statement-list> }

and are used as the body of a function or anywhere that a single statement is expected.

Expression statements

A statement of the form

  <optional-expression> ;

is an expression statement. If the expression is missing, the statement is called a null statement.

Selection statements

C has three types of selection statements: two kinds of if and the switch statement.

The two kinds of if statement are

  if (<expression>) 
     <statement>

and

  if (<expression>) 
     <statement>
  else 
     <statement>

In the if statement, if the expression in parentheses is nonzero or true, control passes to the statement following the if. If the else clause is present, control will pass to the statement following the else clause if the expression in parentheses is zero or false. The two are disambiguated by matching an else to the next previous unmatched if at the same nesting level. Braces may be used to override this or for clarity.

The switch statement causes control to be transferred to one of several statements depending on the value of an expression, which must have integral type. The substatement controlled by a switch is typically compound. Any statement within the substatement may be labeled with one or more case labels, which consist of the keyword case followed by a constant expression and then a colon (:). No two of the case constants associated with the same switch may have the same value. There may be at most one default label associated with a switch; control passes to the default label if none of the case labels are equal to the expression in the parentheses following switch. Switches may be nested; a case or default label is associated with the smallest switch that contains it. Switch statements can "fall-through", that is, when one case section has completed its execution, statements will continue to be executed downward until a break statement is encountered. This may prove useful in certain circumstances, newer programming languages forbid case statements to "fall-through". In the below example, if <label2> is reached, the statements <statements 2> are executed and nothing more inside the braces. However if <label1> is reached, both <statements 1> and <statements 2> are executed since there is no break to separate the two case statements.

  switch (<expression>) {
     case <label1> :
        <statements 1>
     case <label2> :
        <statements 2>
        break;
     default :
        <statements>
  }

Iteration statements

C has three forms of iteration statement:

  do 
     <statement>
  while (<expression>);

  while (<expression>)
     <statement>

  for (<expression> ; <expression> ; <expression>)
     <statement>

In the while and do statements, the substatement is executed repeatedly so long as the value of the expression remains nonzero or true. With while, the test, including all side effects from the expression, occurs before each execution of the statement; with do, the test follows each iteration.

If all three expressions are present in a for, the statement

  for (e1; e2; e3)
     s;

is equivalent to

  e1;
  while (e2) {
     s;
     e3;
  }

Any of the three expressions in the for loop may be omitted. A missing second expression makes the while test nonzero, creating an infinite loop.

Jump statements

Jump statements transfer control unconditionally. There are four types of jump statements in C: goto, continue, break, and return.

The goto statement looks like this:

  goto <identifier>;

The identifier must be a label located in the current function. Control transfers to the labeled statement.

A continue statement may appear only within an iteration statement and causes control to pass to the loop-continuation portion of the smallest enclosing such statement. That is, within each of the statements

  while (expression) {
     /* ... */
     cont: ;
  }

  do {
     /* ... */
     cont: ;
  } while (expression);

  for (optional-expr; optexp2; optexp3) {
     /* ... */
     cont: ;
  }

a continue not contained within a nested iteration statement is the same as goto cont.

The break statement is used to get out of a for loop, while loop, do loop, or switch statement. Control passes to the statement following the terminated statement.

A function returns to its caller by the return statement. When return is followed by an expression, the value is returned to the caller of the function. Flowing off the end of the function is equivalent to a return with no expression. In either case, the returned value is undefined.

Operator precedence in C89

     () [] -> . ++ -- (cast)     postfix operators
     ++ -- * & ~ ! + - sizeof    unary operators
     * / %                       multiplicative operators
     + -                         additive operators
     << >>                       shift operators
     <  <=  >  >=                relational operators
     == !=                       equality operators
     &                           bitwise and
     ^                           bitwise exclusive or
     |                           bitwise inclusive or
     &&                          logical and
     ||                          logical or
     ?:                          conditional operator
     = += -= *= /= %= <<= >>=
         &= |= ^=                assignment operators 
     ,                           comma operator

Data declaration

Elementary data types

The values in the <limits.h> and <float.h> headers determine the ranges of the fundamental data types. The ranges of the float, double, and long double types are typically those mentioned in the IEEE 754 Standard.

name	minimum range
`char`	-127..127 or 0..255
`unsigned char`	0..255
`signed char`	-127..127
`int`	-32767..32767
`short int`	-32767..32767
`long int`	-2147483647..2147483647
`float`	1e-37..1e+37 (positive range)
`double`	1e-37..1e+37 (positive range)
`long double`	1e-37..1e+37 (positive range)

Arrays

If a declaration is suffixed by a number in square brackets ([]), the declaration is said to be an array declaration. Strings are just character arrays. They are terminated by a character zero (represented in C by '\0', the null character).

Examples:

   int myvector [100];
   char mystring [80]; 
   float mymatrix [3] [2] = {2.0 , 10.0, 20.0, 123.0, 1.0, 1.0}
   char lexicon  [10000] [300] ;  /* 10000 entries with max 300 chars each. */
   int a[3][4];

The last example above creates an array of arrays, but can be thought of as a multidimensional array for most purposes. The 12 int values created could be accessed as follows:

`a[0][0]`	`a[0][1]`	`a[0][2]`	`a[0][3]`
`a[1][0]`	`a[1][1]`	`a[1][2]`	`a[1][3]`
`a[2][0]`	`a[2][1]`	`a[2][2]`	`a[2][3]`

Pointers

If a variable has an asterisk (*) in its declaration it is said to be a pointer.

Examples:

   int *pi; /* pointer to int */
   int *api[3]; /* array of 3 pointers to int */
   char **argv; /* pointer to pointer to char */

The value at the address stored in a pointer variable can then be accessed in the program with an asterisk. For example, given the first example declaration above, *pi is an int. This is called "dereferencing" a pointer.

Another operator, the & (ampersand), called the address-of operator, returns the address of variable, array, or function. Thus, given the following

  int i, *pi; /* int and pointer to int */
  pi = &i;

i and *pi could be used interchangeably (at least until pi is set to something else).

Strings

Strings may be manipulated without using the standard library. However, the library contains many useful functions for working with both zero-terminated strings and unterminated arrays of char.

The most commonly used string functions are:

strcat(dest, source) - appends the string source to the end of string dest
strchr(s, c) - finds the first instance of character c in string s and returns a pointer to it or a null pointer if c is not found
strcmp(a, b) - compares strings a and b (lexical ordering); returns negative if a is less than b, 0 if equal, positive if greater.
strcpy(dest, source) - copies the string source to the string dest
strlen(st) - return the length of string st
strncat(dest, source, n) - appends a maximum of n characters from the string source to the end of string dest; characters after the null terminator are not copied.
strncmp(a, b, n) - compares a maximum of n characters from strings a and b (lexical ordering); returns negative if a is less than b, 0 if equal, positive if greater.
strncpy(dest, source, n) - copies a maximum of n characters from the string source to the string dest
strrchr(s, c) - finds the last instance of character c in string s and returns a pointer to it or a null pointer if c is not found

The less important string functions are:

strcoll(s1, s2) - compare two strings according to a locale-specific collating sequence
strcspn(s1, s2) - returns the index of the first character in s1 that matches any character in s2
strerror(err) - returns a string with an error message corresponding to the code in err
strpbrk(s1, s2) - returns a pointer to the first character in s1 that matches any character in s2 or a null pointer if not found
strspn(s1, s2) - returns the index of the first character in s1 that matches no character in s2
strstr(st, subst) - returns a pointer to the first occurrence of the string subst in st or a null pointer if no such substring exists.
strtok(s1, s2) - returns a pointer to a token within s1 delimited by the characters in s2.
strxfrm(s1, s2, n) - transforms s2 into s1 using locale-specific rules

File Input / Output

In C, input and output are performed via a group of functions in the standard library. In ANSI/ISO C, those functions are defined in the <stdio.h> header.

Standard I/O

Three standard I/O streams are predefined:

stdin standard input
stdout standard output
stderr standard error

These streams are automatically opened and closed by the runtime environment, they need not and should not be opened explicitly.

The following example demonstrates how a filter program is typically structured:


#include <stdio.h>

int main()
{
   int c;

   while (( c = getchar()) != EOF ) {
         /* do various things 
            to the characters */

          if (anErrorOccurs) {
              fputs("an error eee occurred\n", stderr);
              break;
          }

         /* ... */
         putchar(c);
         /* ... */

    }
    return 0;
}

Passing command line arguments

The parameters given on a command line are passed to a C program with two predefined variables - the count of the command line arguments in argc and the individual arguments as character arrays in the pointer array argv. So the command

 myFilt p1 p2 p3

results in something like

File:CCommandLineArgv.png

(Note: there is no guarantee that the individual strings are contiguous.)

The individual values of the parameters may be accessed with argv[1], argv[2], and argv[3].

The C Library

Many features of the C language are provided by the standard C library. A "hosted" implementation provides all of the C library. (Most implementations are hosted, but some, not intended to be used with an operating system, aren't.) Access to library features is achieved by including standard headers via the #include preprocessing directive.

See ANSI C standard library, GCC (GNU C Compiler).

References

The C Programming Language, by Brian Kernighan and Dennis Ritchie. Also known as K&R. This is good for beginners.
- 1st, Prentice-Hall 1978; ISBN 0-131-10163-3. Pre-ANSI C.
- 2nd, Prentice-Hall 1988; ISBN 0-131-10362-8. ANSI C.

The C Standard, edited by the British Standard Institute. The official ISO standard (C99) in book form.
- Wiley, 2003; ISBN 0-470-84573-2.

C: A Reference Manual, by Samuel P. Harbison and Guy L. Steele. This book is excellent as a definitive reference manual, and for those working on C compiler and processors. The book contains a BNF grammar for C.
- 4th, Prentice-Hall 1994; ISBN 0-133-26224-3.
- 5th, Prentice-Hall 2002; ISBN 0-130-89592-X.

External links

This article (or an earlier version of it) contains material from FOLDOC, used with permission.