C programming language

C is a programming language designed by Dennis Ritchie during 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.

Table of contents

1 Features 2 History 3 Versions of C 3.1 K&R C 3.2 ANSI C and ISO C 3.3 C99 4 "Hello, World!" in C 5 Anatomy of a C Program 5.4 Control structures 5.4.1 Compound statements 5.4.2 Expression statements 5.4.3 Selection statements 5.4.4 Iteration statements 5.4.5 Jump statements 5.5 Operator precedence in C89 5.6 Data declaration 5.6.6 Elementary data types 5.6.7 Arrays 5.6.8 Pointers 5.7 Strings 5.8 File Input / Output 5.8.9 Standard/A> 6 The C Library 7 References 8 External links

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 standardized set of library routines, which provide features that are useful but not strictly essential.
• 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

For example, the following code, according to the standard, produces undefined behavior.

\r\n#include \r\n#include \r\n\r\nint main (void) {\r\n   char *s = "Hello World!\\n";\r\n\r\n   strcpy (s, s+1); /* remove first character from string s --\r\n                       s = s+1;\r\n                       is probably what the programmer wanted\r\n                     */\r\n   return 0;\r\n}\r\n

"Undefined behavior" means that the resulting program can do anything, including working as the programmer intended it to, crashing horribly every time it is run, or insidously crashing only every 42nd time the program is run, or crashing whenever the machine is rebooted, etc., ad nauseam.

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, it is only a "higher-level" language when compared to assembly language, and is significantly lower-level than most other programming languages. Most prominently, 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.

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 unguarded buffer overrun potential is the mechanism used by many computer virus and computer worm designers.

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, which itself was a revision of an earlier language bon, named after Ken Thompson's wife Bonnie.

By 1973, the C language had become powerful enough that most of the kernel of the Unix operating system was reimplemented in C, perhaps following the examples of the Multics system (implemented in /A>), Tripos (implemented in BCPL), and perhaps others. In 1978, Ritchie and Brian Kernighan published The C Programming Language (a.k.a. "the white book", or K&R.) For many years, this book served as the specification of the language; even today, it enjoys great popularity as a manual and learning 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.

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).

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 use 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
• functions returning struct or union types
• void * data type
• const qualifier to make an object read-only
• struct field names in a separate name space for each struct type
• assignment for struct data types
• the stdio library and some other standard library functions became available with most implementations (these already existed in at least one implementation at the time of K&R, but were not really standard, and thus not documented in the book)
• the stddef.h header file and several other standard header files.

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. (In fact, 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 (in line with 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 comments beginning with // as in C++ (already supported by many C89 compilers as a non-ANSI extension)
• several new library functions, including snprintf
• several new header files, including stdint.h

"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 variation of this program appeared for the first time in K&R.

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

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 the program begins executing at the beginning of main. 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. The programmer may write some of these functions and others may be called from libraries. In the above example return 0 gives the return value for the main function. This indicates a successful execution of the program to a calling shell program.

A C function consists of a return type, a name, a list of parameters (or void in parentheses if there are none) and a function body. 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

  {   }

Expression statements

A statement of the form

   ;

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 () 
     

  if () 
     
  else 
     

  switch () {
     case  :
        
     case  :
        
        break;
     default :
        
  }

  do 
     
  while ();

  while ()
     

  for ( ;  ; )
     

  for (e1; e2; e3)
     s;

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

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>;

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

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

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

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

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];

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 */

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

Strings

Standard/H4> Three standard I/code> standard input

stdout standard output

stderr standard error

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

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

include 

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

 myFilt p1 p2 p3 

(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

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.
  • 2nd, Prentice-Hall 1988; ISBN 0-131-10362-8.

• 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.

• Dennis M. Ritchie, The Development of the C Language
• Brian W. Kernighan, Programming in C: A Tutorial
• Lysator C language resource list
• The newsgroup comp.lang.c FAQ by Steve Summit