Tutorial Introduction to C

• History of C
  • UNIX developed in 1969 in BCPL - a language for writing compilers and system tools.
  • A new version written in 1970 in B - a cut down version of BCPL
  • A totally new language C in 1972 - a successor to B
  • By 1973 UNIX almost totally written in C.
• Characteristics of C
  • Small size
  • Extensive use of function calls
  • Loose typing
  • Structured language
  • No objects
  • Low level (bitwise) programming readily available
  • Pointer implementation - extensive use of pointers for memory, array, structures and functions.
  • Not object oriented (no classes, objects, inheritance, etc.)
• C has now become a widely used professional language for various reasons.
  • It has high-level constructs.
  • It can handle low-level activities.
  • It produces efficient programs.
  • It can be compiled on a variety of computers.
• As an extreme example the following C code (Mystery.c) is actually legal C code. Credit to Ian Phillipps.

  main(t,_,a)
  char *a;
  {return!0<t?t<3?main(-79,-13,a+main(-87,1-_,
  main(-86, 0, a+1 )+a)):1,t<_?main(t+1, _, a ):3,main ( -94, -27+t, a
  )&&t == 2 ?_<13 ?main ( 2, _+1, "%s %d %d\n" ):9:16:t<0?t<-72?main(_,
  t,"@n'+,#'/*{}w+/w#cdnr/+,{}r/*de}+,/*{*+,/w{%+,/w#q#n+,/#{l,+,/n{n+\
  ,/+#n+,/#;#q#n+,/+k#;*+,/'r :'d*'3,}{w+K w'K:'+}e#';dq#'l q#'+d'K#!/\
  +k#;q#'r}eKK#}w'r}eKK{nl]'/#;#q#n'){)#}w'){){nl]'/+#n';d}rw' i;# ){n\
  l]!/n{n#'; r{#w'r nc{nl]'/#{l,+'K {rw' iK{;[{nl]'/w#q#\
  n'wk nw' iwk{KK{nl]!/w{%'l##w#' i; :{nl]'/*{q#'ld;r'}{nlwb!/*de}'c \
  ;;{nl'-{}rw]'/+,}##'*}#nc,',#nw]'/+kd'+e}+;\
  #'rdq#w! nr'/ ') }+}{rl#'{n' ')# }'+}##(!!/")
  :t<-50?_==*a ?putchar(a[31]):main(-65,_,a+1):main((*a == '/')+t,_,a\
  +1 ):0<t?main ( 2, 2 , "%s"):*a=='/'||main(0,main(-61,*a, "!ek;dc \
  i@bK'(q)-[w]*%n+r3#l,{}:\nuwloca-O;m .vpbks,fxntdCeghiry"),a+1);}
            

  • It will compile and run and produce meaningful output. Try this program out.
  • Clearly nobody ever writes code like or at least should never. This piece of code actually won an international Obfuscated C Code Contest.
• The standard for C programs was originally the features set by Brian Kernighan. In order to make the language more internationally acceptable, the ANSI C standard was published in 1990, and the ISO C99 standard in 1999. C99 is a common standard to which programmers adhere.

//-----------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
//-----------------------------------------------------------------------------
int main(void) {

    printf("Hello, world\n");

    return(EXIT_SUCCESS);
}
//-----------------------------------------------------------------------------
     

• The #includes include definitions of standard i/o library functions and standard odds-and-ends. In general, #include includes a file.
  • Include files end with .h.
  • If the file name is enclosed in <>, the standard include file directories (e.g., /usr/include on UNIX systems) are searched for the file.
  • If enclosed in "", the current directory is searched, then the standard include file directories.
• A C program consists of one or more functions.
  • Every program must have a main function somewhere. Execution starts with the main function and ends when it returns (other happy endings are possible too :-) (and there are some unhappy endings :-().
  • int before main indicates that main returns an integer value.
  • () following the function name surrounds the argument list. void here indicates that there are no arguments.
  • {} enclose the statements that make up the function.
• C is case sensitive, main is not the same as Main, etc.
• printf is a general purpose format conversion function.
  • printf is not part of the C language.
  • printf calls a standard function that is held in a library and linked in at link time.
  • printf is defined in stdio.h for compiler checking.
  • Its output goes to stdout
  • A sequence of characters in "..." is called a character string or string constant.
  • \n is for newline.
• The return sends the integer value back, via the OS, to the parent process. EXIT_SUCCESS is the standard success return value, and EXIT_FAILURE is the standard value when something has gone wrong.

• By convention the filename must end .c, e.g. MyProgram.c
• There are many C compilers around.
  • The cc is the default compiler. Often it's simply an alias for ...
  • The GNU C compiler gcc is popular and available for many platforms.
  • Other (less common) C compilers exist.
  • All the compilers operate in essentially the same manner and share many common command line options.
  • The best source of information for each compiler is through the online manual pages: e.g., man gcc.
• To compile your program simply invoke the compiler followed by the name of the (C) program you wish to compile. E.g.,

  prompt> gcc Program.c 

• If there are language errors in your program the compiler will detect and report them.
  • The -Wall option will make the compiler warn about code that can be compiled but looks dodgy ... use it.
  • The -ansi option will raise errors for non-ANSI standard constructs.
  • The -pedantic option will make the compiler compile strictly to ANSI standards ... it's not necessary.
• The compiled version, or executable, is left in a file called a.out, or, if the compiler option -o is used, the file listed after the -o.
  • It is convenient to use a -o and filename in the compilation as in

    prompt> gcc -Wall -o Program Program.c 

• To run an executable in UNIX, you simply type the name of the file containing it, e.g.,

  prompt> a.out
  prompt> Program 

• This assumes you have . in your path variable. If you don't you have to precede the file name with ./ to say "look in the current directory".

• FahrCelciusWhile.c - Program to convert fahrenheit to celcius using a while loop.
• //... is a comment through to the end of the line
  • Comments may also be written within /* ... */ pairs. Such comments may extend over multiple lines.
  • Comments do not nest.
• Variable definitions reserve memory for the variables.
  • This consists of a type and a list of variables.
  • The basic data types are char, int, float, double. These can variously be modified with short, long, long long signed, unsigned.
  • Other data types are arrays, structures, unions, pointers.
• Everything should be declared before use.
  • Declaration gives structure information.
  • A definition gives the details
  • A definition serves as a declaration.
• = is for assignment.
• Non-compound statements are terminated with a ;, and compond statements are enclosed in {}s
• The while loop has a familiar look :

  while (<condition>) {
      <statement> 
  }

  • The condition is tested each time before the body is executed.
  • The body may be a single statement or a compound statement (Style suggestion ... always use a compound statement).
• Note the use of indentation, meaningful variable names, etc.
• The comparison/assignment/subtraction of float and int is ok, the ints are automatically converted to float before the comparison/assignment/subtraction occurs.
• 5.0/9.0 is real division - implied by the constants.
  • Integer division truncates.
• printf is a general purpose format conversion function.
  • Its first argument is a string of characters to be printed, with a % sign where and how each of the following arguments should be printed. Each % must correspond by type with a later argument.
  • %4.0f says a floating point is to be printed in a 4 character field with no digits after the decimal point.
  • %f for float, %d for decimal integer, %o for octal, %x for hexadecimal, %c for character, %s for character string and %% for %.
  • \n is for newline, \t for tab, \b for backspace, \" for double quote and \\ for backslash.

• FahrCelciusFor.c - Program to convert fahrenheit to celcius using a for loop.
• The first part of a for statement is done once before the loop is entered.
• The second part is the test that controls whether the loop should be entered.
• The third part is the re-initialisation step that is done at the completion of the body of the loop.
• Can be re-written as a while loop.
• Expressions can be used anywhere values can be used, e.g., in printf.

• FahrCelciusDefine.c - Program to convert fahrenheit to celcius using #define.
• The #define construction at the beginning of a program can define a symbolic name or symbolic constant.
• A preprocessor replaces all unquoted occurences of the name with the string, before the compiler starts.
• Symbolic constants are normally written in upper case to distinguish them from variables.
• There is no ; at the end of the definition.
• Statements can span over several lines, but must not be broken in mid-character string or word.

• File copying
  • FileCopy.c - Program to copy input to output.
  • Input and output is considered to be a stream of characters. A special character is the new line character \n, which breaks the stream up into lines.
  • getchar() returns the next character on stdin as an integer. e.g. c=getchar(). The return value is integer to facilitate the return of EOF, which is a symbolic constant defined in stdio.h, and is often -1. Hence C1 is defined as an integer.
  • From the keyboard EOF is generated by a line containing ^D
  • putchar(C) prints (portably, the last 7 bits of, see limits.h for the local width of a char) integer C onto stdout as a character. It also returns an int value (see later).
  • Calls to putchar and printf may be interleaved, the output will appear in same order.
  • getchar and putchar declarations reside in stdio.h.
  • The return value from function putchar has been ignored. This is always ok.
  • != means not equal to
  • In C any assignment can be used as an expression, its value being the value assigned to the LHS.
    • FileCopy2.c - Program to copy input to output.
    • The () round the assignment are necessary as != has higher precedence than =.
• Character counting.
  • CharCount.c - Program to count characters.
  • ++ is an operator that increments by one. There is also -- which decrements by one. These two operators may be postfix (NumberOfCharacters++) or prefix (++NumberOfCharacters) with slightly different effects. See later.
  • The use of long allows a much larger number of characters to be input before overflow occurs.
  • The format %ld is for long integers.
  • An alternative way.
    • CharCount2.c - Program to count characters.
    • The body of the for loop is empty (could also be done with a ;)
    • .0f suppresses the printing of the decimal point and fractional part.
• Line counting.
  • LineCount.c - Program to count lines.
  • == tests for equality.
  • The if statement tests the condition in ()
  • A single character is written between ''s, e.g. 'A' This is called a character constant, and is converted to the numeric value that represents that character, e.g., 65. Hence compatibility between characters and integer.
• Word counting.
  • AllCount.c - Program to count lines, words, and chars.
  • The symbolic constants YES and NO make the program readable and flexible. In addition they make sense as false is associated with 0 and true with non-0 integers. Correspondingly, int is used for Boolean variables.
  • The initialisation in one line is possible as assignment has a value and associates right to left. i.e. Lines = (Words = (Characters = 0));
  • The operator || means inclusive or. && is for and. Logical expressions are evaluated left to right and as soon as the truthhood is known the evaluation stops. This useful in complicated situations.
  • The C if-then-else statement has the form :

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

    (Style hint ... use compound statements)
  • ! negates a "Boolean" value, changing 0 to 1 and non-0 to 0.

• ProgramStructure2.c - Program with functions.
• A C function can act as a procedure or a function. If the type is void then no value is returned, and the function acts as a procedure.
  • A value is returned via the return statement. If a value is returned the function acts as a true function and is invoked by using the function name as a value.
  • A return statement without a value causes control but no value to be returned, as does "falling-off-the-end". In this situation the function acts as a procedure and may be invoked via the function name.
  • Functions that return values may have their return values ignored, and be treated like procedures.
  • A function may have multiple returns.
• Variables declared in a function are local and temporary (unless specified otherwise - see later).
• ANSI standard compilers provide prototyping which allows a function to be completely (including arguments) declared before use, to improve compiler error checking.
  • If not declared a (probably inappropriate) default is used.
  • If the function is defined before use, this will act as a declaration.
    • Thus the functions could be put before main, and the declarations left out.
    • ProgramStructure.c - Program with functions before main.
    • The declaration style makes it easy to convert to a multi-file program - see later.
  • All library functions have their prototypes in the appropriate header file, which must be included.
• A C program may be distributed over multiple files, and functions called between files. In every case, a function must be declared before use.

• In C all function arguments except arrays are passed by value, i.e. the arguments are re-created locally when the function is invoked and the appropriate values copied from the invokation. Thus this version alters Exponent, but that does not affect the actual argument in the call.
• PowerFunction.c - Program with function with arguments
• Pass by reference can be achieved by explicitly passing the address of (pointer to) a variable.
• PowerFunctionPointer.c - Program with function with pointer argument
• An array is passed to a function argument as the address of the first element of the array (which can be treated like an array). Thus arrays are passed by reference, and arrays are somewhat interchangable with pointers.

• WhiteCount.c - Program to count white space and digits and others
• The declaration int Digits[10]; declares an array of 10 integers. In C the subscripts to arrays always start at 0.
• Beware - no seat belts, no airbags. C does not check array subscripts.
  • Source of many security problems.
• By definition arithmetic involving ints and chars converts everything to int before proceeding, so C1-'0' has an integer result.

• LongestLine.c - Program to find the longest line in the input.
• The argument declaration char Line[] declares that Line is an array of characters. The length need not be supplied as C doesn't care.
• C represents character strings internally by the sequence of characters followed by the '\0' character. The %s format expects strings to be in this form. Character arrays that are to hold strings need to be defined one too long.
• GetLine puts the character '\0' at the end of the array to follow the standard representation. Similarly, Copy detects the end of the string when it reaches this character.
• The left to right evaluation of logical expressions is useful in GetLine's for loop.

• ReadPeople.c - Program using formatted IO for reading and writing people
• int scanf(char control[],<arg1>,<arg2>,....);
• scanf reads and converts input from the standard input stream under the control of the control argument.
• The control string controls input conversion.
• The following arguments must all be addresses.
  • Arrays = give name
  • Other variables = preceed with &.
• A conversion specification starts with a % and ends with a conversion character.
• Some conversion characters are :
• d = int * <- decimal integer
• c = char * <- character (default one character). White space skip is suppressed. Use %1s to skip white space.
• s = char * (char []) <- character string. \0 is added to the input.
• f,e,g = float * <- real
• Example

      int i1;
      float f1;
      char name[50];
  
      scanf("%2d %f %*d %2s",&i1,&f1,name)
            

  with input 56789 1234 45a72 gives i1=56, f1=789.0 , name="45"

The area of a circle of radius ... units is .... units.  

333.3 centimeters is 10 feet 11.2 inches.  

322 seconds is equivalent to 2 hours 2 minutes 2 seconds.