The C Programming Language

1
The C Programming Language

• Eric Vidal
• CS 280

2
What is C?

• Originally System programming language for the
  UNIX operating system
• Today One of the most dominant development
  languages for general purpose applications,
  especially for low-level software

3
Sample C Programs

• Hello, world!
• include ltstdio.hgt
• int main(int argc, char argv, char envp)
• printf("Hello, world!\n")
• return 0

4
Sample C Programs

• Quicksort
• include ltstdio.hgt
• void quicksort(int array, int start, int end)
• int last_start start, last_end end, swap
• / we do not need to sort zero/one item
  arrays /
• if (start gt end)
• return
• / move items greater than pivot to the end
  /
• / and keep items less than pivot at the
  start /
• start
• while (start lt end)
• if (arraystart gt arraylast_start)

• / move pivot to the center of the array /
• if (arraystart gt arraylast_start)
• start--
• swap arraylast_start
• arraylast_start arraystart
• arraystart swap
• / recursively sort array before and after
  pivot /
• quicksort(array, last_start, start - 1)
• quicksort(array, start 1, last_end)
• int main(int argc, char argv, char envp)
• int foo7 4, 1, 6, 10, 9, 7, 3
• int i

5
Real-World C Applications

• Most modern operating systems
• Kernel Linux kernel, NT kernel, etc.
• Command line processors bash, csh, cmd.exe,
  etc.
• Native windowing system X Window System,
  Windows Shell
• Other utilities grep, make, etc.
• Most modern compilers
• GNU Compiler Collection gcc, g, etc.
• Visual Studios base compilers cl.exe, rc.exe,
  etc.
• Most modern PC and console games ?

6
Evolution of C

• CPL Cambridge Programming Language or Combined
  Programming Language (1963)
• Invented by Christopher Strachey, et al.
• Heavily influenced by Algol 60
• Too complex to implement on existing computers
• BCPL Basic CPL (1966)
• Invented by Martin Richards
• Programming language of choice for the Multics
  systems in Bell Laboratories

7
Evolution of C

• B Programming Language (1969)
• Invented by Ken Thompson
• Implemented on a DEC PDP-7 with 8K 18-bit words
  of memory
• Intended as the system implementation language
  for UNIX
• Revision of an earlier language, Bon
• Not named after the B in BCPL, but heavily
  influenced by it

8
Evolution of C

• BCPL versus B versus C
• BCPL and B are both typeless C has types
• Pointers and arrays are both integer indexes to
  the memory array
• In BCPL In B In C
• let v vec 10 auto v10 int v10
• v!i 42 vi 42 vi 42
• In B (unlike in BCPL and C), output is not native
  code, but threaded code which operates on a stack
  machine
• BCPL (unlike B and C) allows nested procedures,
  and links between separately compiled modules
  must be explicitly stated

9
Evolution of C

• NB New B (1971)
• Invented by Dennis Ritchie
• On the DEC PDP-11 with 12K 16-bit words of
  memory, character data is not accessed in words
  but in bytes
• Required two distinct data types int and char
• Floating point arithmetic will also require a new
  float data type
• NB compiles to native code

10
Evolution of C

• NB versus C
• Previously, arrays and pointers are the same, but
  Ritchie wanted to implement structures
• struct direntry
• int inumber
• char name14
• Pointer to an array ! actual array in the
  structure
• Inconvenient for reading from disk

11
Evolution of C

• C Programming Language (1972)
• Also invented by Ritchie, proper successor to B
• In C, arrays are still similar to pointers
• Pointer to an array is created only when the
  array name is mentioned in an expression
• Generalization of pointers
• int i, pi, ppi
• int fi(), fpi(), (pfi)()
• int api10, (pai)10

12
Evolution of C

• KR C first C standard (1978)
• Appeared in The C Programming Language by Brian
  Kernighan and Dennis Ritchie
• and operators
• Previously and means both logical and bitwise
  AND and OR
• Unfortunately, precedence was never fixed (to
  preserve compatibility with B)
• if (a mask b) / logical error /
• Preprocessor
• include ltheader.hgt
• define MACRO
• unsigned, long, union, enum
• Type casts

13
Evolution of C

• ANSI C or C89 first official C standard (1989)
• Produced by the ANSI X3J11 working group
• Required the types of formal arguments in the
  type signature of the function
• In KR C In ANSI C
• double sin() double sin(double)
• const, volatile
• Ratified a Standard C Library
• Should be implemented by all ANSI C-compliant
  vendors

14
Evolution of C

• ISO/IEC 9899 C90 second official C standard
  (1990)
• Exactly the same as C89, with changes to
  numbering to reflect ISO practice
• ISO/IEC 9899 C99 current official C standard
  (1999)
• Produced by the ISO/IEC/JTC/SC22/WG14 working
  group
• Added invariant ISO646 and multibyte support
  extensions
• Clarified the existing standard via technical
  corrigenda
• ISO/IEC 9899 TCOR1 (1995)
• ISO/IEC 9899 TCOR2 (1996)
• Available at http//std.dkuug.dk/JTC1/SC22/WG14/

15
Disadvantages of C

• Ambiguity in variable use
• Type safety (integers versus pointers)
• Fence post errors (arrays versus pointers)
• Indirection problems
• int fp()
• int (pf)()
• int (pfp)()
• Treats strings as null-terminated character
  arrays
• Finding the length of the string is O(n)
• Generally not well-suited for string processing

16
Disadvantages of C

• Array problems
• Dynamically changing the size of an array is
  clumsy
• Functions expecting multiple pointers to arrays
  cannot be optimized fully for SIMD or vector
  machines arrays may overlap
• Modularization problems
• Only two levels of naming external (global) and
  internal (function)
• Developers must create their own modularization
  conventions

17
Disadvantages of C

• Memory problems
• C itself only provides two types of storage
  automatic (in the stack segment) and static (in
  the data segment)
• Dynamically allocated storage in the heap
  (malloc() and free()) is tedious and error-prone
• Automatic garbage collection is difficult

18
Advantages of C

• Low-level functionality
• Bitwise operators
• Pointers
• Type looseness
• High-level syntax
• Abstract enough to describe underlying algorithms
• Result A language that can do practically
  everything, is portable to other systems, and
  runs as fast as assembly

19
Advantages of C

• Small and simple
• Easy to parse compilers occupy very little
  memory
• Ties with UNIX
• Language not designed in isolation, but in a real
  environment with emphasis on practicality
• Meets the needs of programmers, but does not
  supply too much
• Compatibility with old programs C has been
  remarkably stable through the years (unlike
  FORTRAN or Pascal)

20
Compilers for C

• First C compiler, cc, is developed by Dennis
  Ritchie
• First portable C compiler, pcc, is developed by
  Steve Johnson (1978)
• Became the reference implementation for KR C
• Currently a ton of compilers available
• Mostly because compiler theory classes use a
  subset of C for their final project ?

21
Compilers for C

• Generally available C compilers (also works for
  C)
• Borland CBuilder
• http//www.borland.com/cbuilder/
• Microsoft Visual C .NET
• http//msdn.microsoft.com/visualc/
• The GNU Compiler Collection
• For Linux http//gcc.gnu.org/
• For Windows http//www.mingw.org/

22
References

• Ritchie, Dennis M. The Development of the C
  Language. April 1993. Internet on-line.
  Available from lthttp//cm.bell-labs.com/cm/cs/who/
  dmr/chist.htmlgt 31 July 2003
• International Standards Organization. 2003.
  ISO/IEC JTC1/SC22/WG14 C. Denmark
  International Standards Organization, 2003 cited
  31 July 2003. Available from World Wide Web
  (http//std.dkuug.dk/JTC1/SC22/WG14/)