C Programming Language
- first session -
C Programming Language First Part
The evolution of C What is C ?
Strengths and weaknesses
Overview of C programming
Lexical elements
The C preprocessor
Q&A
What is C ?
The 'C' programming language was originally developed for and implemented on the
UNIX operating system, by Dennis Ritchiein 1971.
One of the best features of C is that it is not tied to any particular hardware or system.
This makes it easy for a user to write programs that will run without any changes on
practically all machines.
C is often called a middle-level computer language as it combines the elements of
high-level languages with the functionalism of assembly language.
The evolution of C
When
Who, where
Comments
mid-1960
Ken Thompson, Bell
Laboratories
Developed B language (based on BCPL which in turn is
based on Algol-60) for UNIX Operating System
development
A higher-level programming language was needed for
further development of the system (prior, assembly
language was used)
1971
Denis Ritchie, Bell
Laboratories
Developed an extended version of B called NB (New B)
and then changed its name into C
1973
UNIX was rewritten in C
1978
Brian Kernighan and
Denis Ritchie
The C Programming Language 1st edition, referred as
K&R - it was the de facto standard
The evolution of C
When
Comments
1983
ANSI (American National Standards Institute) starts the standardization process
of the C programming language
1989
Standard adopted as ANSI Standard X3.159-1989 ANSI-C
1990
Standard adopted by ISO as an international standard ISO/IEC 9899:1990
C89 or C90
1995
Amendment 1 extension to C89 C89 with Amendamne1 or C95
1999
New C standard adopted as ISO/IEC 9899:1999 C99
Changes are in the spirit of C they do not change the fundamental nature of
the language
C99 isnt yet universal and it will take time before all compilers are C99
compliant
Latest Infos on http://www.open-std.org
Strengths and weaknesses
Strengths
Weaknesses
Efficiency: programs execute fast and use
limited amounts of memory
Programs can be error-prone: C allows
some programming mistakes to go
undetected (e.g. the use of & operator)
Portability: programs may run on different
computing systems
Programs can be difficult to understand:
C allows to write programs in a quite cryptic
manner (e.g. a[(i>>1) + j] += i>>j;)
Power: C has a large collection of types and
operators
Programs can be difficult to modify: Large
programs can be hard to modify if they
havent been designed with maintenance in
mind
Flexibility: C may be used to write programs
for embedded systems or for commercial
data processing systems
Standard library: has plenty of functions for
I/O, string processing, storage allocation, etc.
Overview of C programming
EXAMPLE
A C program is composed of one or
more source files, each of which
contains some part of the entire C
program: typically some number of
external functions
Common declarations are often
collected into header files and are
included into the source files with a
special #include command
One external function must be
named main and this function is
where the program starts
#include <stdio.h>
#define SIZE = 10
int size(int a[SIZE])
{
int ret;
ret=printf("size of array is:%d\n", sizeof(a));
return ret;
}
int main()
{
int a[SIZE];
(void)size(a);
return 0;
}
Q: Will the program compile?
Q: What would be the output of the
program?
Q: What would be the value returned by the
function size?
Overview of C programming: Embedded vs. Desktop Programming
Overview of C programming
A C compiler independently processes each
source file and translates the C program text
into instructions understood by the computer
The output of the compiler is usually called
object code or an object module
When all source files are compiled, the object
modules are given to a program called the
linker
The linker resolves references between the
modules, adds functions from the standard
run-time library
The linker produces a single executable
program which can then be invoked or run
C source
file
C source
file
Compile
Compile
Object
file
Object
file
Link
Executable
module
Library
Overview of C programming A C Program
Lexical elements
In C source programs the blank (space), end-of-line,
vertical tab, form feed, and horizontal tab (if present) are
known collectively as whitespace characters.
Comments are also whitespace
The end-of-line character or character sequence marks the
end of source program lines. In some implementations, the
formatting characters carriage return, form feed, and (or)
vertical tab additionally terminate source lines and are
called line break characters
EXAMPLE
if (a==b) X=1; el\
se X=2;
Is equivalent to the single line
if (a == b) X=1; else X=2;
EXAMPLE
#define nine (3*3)
A source line can be continued onto the next line by
ending the first line with a reverse solidus or backslash
(\) character. The backslash and end-of-line marker are
removed to create a longer, logical source line
Is equivalent to
#define nine /* this
is nine
*/ (3*3)
Lexical elements
Comments:
Traditionally, a comment begins with an occurrence of
the two characters /* and ends with the first
subsequent occurrence of the two characters */
Beginning with C99, a comment also begins with the
characters // and extends up to (but does not include)
the next line break
Comments are not recognized inside string or
character constants or within other comments
Comments are removed by the compiler before
preprocessing
Standard C specifies that all comments are to be
replaced by a single space
EXAMPLE
// Program to compute the squares of
// the first 10 integers
#include <stdio.h>
void Squares ( /* no arguments */ )
{
int i;
/*
Loop from 1 to 10,
printing out the squares
*/
for (i=1; i<=10; i++)
printf("%d //squared// is %d\n,i,i*i);
}
EXAMPLE
To cause the compiler to ignore large parts
of a C program, it is best to enclose the
parts to be removed with the preprocessor
commands
#if 0
#endif
rather than insert /* before and */ after the
text.
Lexical elements
An identifier or name, is a sequence of Latin capital and small letters, digits, and the
underscore character
An identifier must not begin with a digit, and it must not have the same spelling as a keyword. C
is case sensitive
Standard C further reserves all identifiers beginning with an underscore and followed by either
an uppercase letter or another underscore
C89 requires implementations to permit a minimum of 31 significant characters in identifiers, and
C99 raises this minimum to 63 characters
External identifiers those declared with storage class extern may have additional spelling
restrictions: C89 requires a minimum capacity of only six characters, not counting letter case.
C99 raises this to 31 characters
The C preprocessor - overview
The C preprocessor is a simple macro processor that conceptually
processes the source text of a C program before the compiler proper reads the
source program
The preprocessor is controlled by special preprocessor command lines, which
are lines of the source file beginning with the character #
The preprocessor typically removes all preprocessor command lines from the
source file and makes additional transformations on the source file as
directed by the commands
The syntax of preprocessor commands is completely independent of
(although in some ways similar to) the syntax of the rest of the C language
The C preprocessor - overview
The preprocessor does not parse the source
text, but it does break it up into tokens for
the purpose of locating macro calls
Standard C permits whitespace to precede
and follow the # character on the same
source line
C source
file
Preprocess
Modified C
source file
Compile
Preprocessor lines are recognized before
macro expansion
Object code
The C preprocessor
Command
Meaning
#define
Define a preprocessor macro
#undef
Remove a preprocessor macro definition.
#include
Insert text from another source file.
#if
Conditionally include some text based on the value of a constant expression.
#ifdef
Conditionally include some text based on whether a macro name is defined.
#ifndef
Conditionally include some text with the sense of the test opposite to that of #ifdef.
#else
Alternatively include some text if the previous #if, #ifdef , #ifndef, or #elif test failed.
#endif
Terminate conditional text.
#line
Supply a line number for compiler messages.
defined
Preprocessor function that yields 1 if a name is defined as a preprocessor macro and 0 otherwise; used in #if and #elif.
# operator
Replace a macro parameter with a string constant containing the parameter's value.
## operator
Create a single token out of two adjacent tokens.
#pragma
Specify implementation-dependent information to the compiler.
#error
Produce a compile-time error with a designated message.
The C preprocessor - #define
The #define preprocessor command causes a name
(identifier) to become defined as a macro to the
preprocessor
EXAMPLES
A sequence of tokens, called the body of the macro, is
#define BLOCK _SIZE 0x100
#define TRACK _SIZE (16-BLOCK_ SIZE)
associated with the name
#define product(x,y) ((x)*(y))
The #define command has two forms:
An object like macro takes no arguments. It is
invoked by mentioning its name
A function like macro declares the names of formal
parameters within parentheses separated by commas
The left parenthesis must immediately follow
the name of the macro with no intervening
whitespace
#define incr(v,low,high) \
for ((v) = (low); (v) < = (high); (v) ++))
#ifndef MAXTABLESIZE
#define MAXTABLESIZE 1000
#endif
The C preprocessor - #define
Once a macro call has been expanded, the scan for macro calls resumes at the beginning
of the expansion so that names of macros may be recognized within the expansion for the
purpose of further macro replacement
Macros appearing in their own expansion-either immediately or through some intermediate
sequence of nested macro expansions-are not re-expanded in Standard C
EXAMPLE
#define plus(x,y) add(y,x)
#define add(x,y) (x)+(y)
the invocation plus(plus(a,b),c) is expanded as shown next
Step
1
2
3
4
5
Result
plus(plus(a,b),c )
add(c,(plus(a,b))
((c)+(plus(a,b)))
((c)+(add(b,a)))
((c)+(((b)+(a))))
#define sqrt(x) ( (x) <0 ? sqrt (-(x)) : sqrt (x))
The C preprocessor - #define
Macros operate purely by textual substitution of
EXAMPLES
tokens:
#define SQUARE(x) x*x
The invocation
SQUARE (z+1)
will be expanded into: z+1*z+1
WHICH IS NOT WHAT WAS INTENDED SOLUTION:
This can lead to surprising results if care is not
taken:
As a rule, it is safest to always parenthesize
each parameter appearing in the macro body
#define SQUARE(x) ((x)*(x))
The invocation
SQUARE (z++)
will be expanded into: (z++)*(z++)
WHICH HAS THE SIDE EFECT OF DOUBLE
INCREMENTING z
The entire body, if it is syntactically an
expression, should also be parenthesized.
Function like macros does not allow the debug
process to trace or step into them. The errors
inside them are hard to find by debugging.
SOLUTION: USE A TRUE FUNCTION NOT A FUNCTION
LIKE MACRO
int square(int x)
{
return x*x;
}
Q: What would be the disadvantage of using a function
instead of a function like macro?
The C preprocessor - #include
The #include preprocessor command causes the entire contents of a specified source text file
to be processed as if those contents had appeared in place of the #include command
The #include command has the following forms in Standard C:
#include <char-sequence>
searches for the file in certain standard places according to implementation-defined search
rules
#include char-sequence
will also search in the standard places, but usually after searching some local places, such
as the programmer's current directory
The C preprocessor - #if,#endif usecase
The preprocessor conditional commands allow lines of
source text to be passed through or eliminated by the
preprocessor on the basis of a computed condition
EXAMPLE
#define X86 0
#define ARM 0
#define PPC 1
#if X86
#endif
#if ARM
The preprocessor replaces any name in the #if expression
that is not defined as a macro with the constant 0
#endif
#if PPC
#endif
X86-dependent code
ARM-dependent code
PPC -dependent code
EXAMPLE
#define X86 1
#undef ARM
#undef PPC
The expressions that may be used in #if and #elif commands
#ifdef X86
include integer constants and all the integer arithmetic,
#endif
#ifdef ARM
relational, bitwise and logical operators
#endif
#ifdef PPC
#endif
X86-dependent code
ARM-dependent code
PPC -dependent code
C Programming Language Second Part
Data representation
Types
Conversions
Q&A
Data representation
All data objects in C except bit fields are represented at run time in the computer's memory in an
integral number of abstract storage units
Each storage unit is made up of some fixed number of bits, each of which can assume either of
two values, denoted 0 and 1
Each storage unit must be uniquely addressable and is the same size as type char
The C Standard also calls storage units bytes: a storage unit consisting of exactly eight bits
The size of a data object is the number of storage units occupied by that data object
Data representation
The addressing model most natural for C is one in
which each character (byte) in the computer's memory
can be individually addressed
i = 305419896 = 0x12345678 (4 bytes)
Little endian
Memory addresses
Memory locations
Computers using this model are called byte-
0x1200
0x78
addressable computers
0x1201
0x56
Byte order establishes which byte of storage is
0x1202
0x34
considered to be the "first" one in a larger piece:
0x1203
0x12
"little-endian" architectures: the address of a 32bit integer is also the address of the low-order
byte of the integer (Intel convention)
Big endian
Memory addresses
Memory locations
0x1200
0x12
"big-endian" architectures the address of a 32-bit
0x1201
0x34
integer is the address of the high-order byte of the
0x1202
0x56
integer (Motorola convention)
0x1203
0x78
Data representation
Others impose alignment restrictions on certain
data types, requiring that objects of those types
occupy only certain addresses
It is not unusual for a byte-addressed computer, for
example, to require that 32-bit (4-byte) integers be
located on addresses that are a multiple of four
The C programmer is not normally aware of
alignment restrictions because the compiler takes
care to place data on the appropriate address
boundaries
i = 305419896 = 0x12345678 (4 bytes)
Aligned on word boundary
Memory locations
Memory addresses
0x1200
0x78
0x1201
0x56
0x1202
0x34
0x1203
0x12
Not aligned on word boundary
Memory locations
Memory addresses
0x1201
0x78
0x1202
0x56
0x1203
0x34
0x1204
0x12
Data Types
Data Types & sizes
Integer types on a 16-bit machine
Standard C specifies the minimum precision for most
integer types:
Type
short int
Type char must be at least 8 bits wide
unsigned short int
type short must be at least 16 bits wide,
int
type long must be at least 32 bits wide
unsigned int
type long long must be at least 64 bits wide.
Standard C requires that: int not be shorter than short int
and long int not be shorter than int
long int
Smallest value
Largest Value
-32768
32767
65535
-32768
32767
65535
-2147483648
2147483647
4294967295
unsigned long int
Integer types on a 32-bit machine
Type
short int
unsigned short int
int
unsigned int
long int
unsigned long int
Smallest value
Largest Value
-32768
32767
65535
-2147483648
2147483647
4294967295
-2147483648
2147483647
4294967295
Data Types
The character type in C is an integral type
Character type specified:
char
signed char
unsigned char
For reasons of efficiency, C compilers are free to treat type char in either of two ways:
Type char may be a signed integral type equivalent to signed char
Type char may be an unsigned integral type equivalent to unsigned char
EXAMPLES
unsigned char uc = -1;
signed char sc = -1;
char c = -1;
int i = uc, j = sc, k = c;
i must have the value 255
j must have the value 1
it is implementation-defined whether k has the value 255 or - 1
Data Types
FIoating-point type specifiers:
float
double
long double (C89)
C does not dictate the sizes to be used for the floating-point types or even that they be different
The programmer can assume that the values representable in type float are a subset of those in type
double, which in turn are a subset of those in type long double
EXAMPLES
double d;
static double pi;
float coefficients [8] ;
long double epsilon;
Types - pointers
For any type T, a pointer type "pointer to T" may be formed
Pointer types are referred to as object pointers or function pointers depending on whether T is an object
type or a function type.
A value of pointer type is the address of an object or function of type T.
The two most important operators used in conjunction with pointers are:
the address operator, &, which creates pointer values
indirection operator, *, which dereferences pointers to access the object pointed to
The size of a pointer is implementation-dependent and in some cases varies depending on the type of the
object pointed to
Types - pointers
EXAMPLES
int i, j, *ip;
ip = &i;
i = 22;
j = *ip; /* j now has the value 22 */
*ip = 17; /* i now has the value 17 */
Variables
i
Memory addresses
0x1200
Memory locations
0x00
0x00
0x1220
0x00
0x00
ip
0x1240
0x00
0x00
Types - pointers
EXAMPLES
int i, j, *ip;
ip = &i;
i = 22;
j = *ip; /* j now has the value 22 */
*ip = 17; /* i now has the value 17 */
Variables
i
Memory addresses
0x1200
Memory locations
0x00
0x00
0x1220
0x00
0x00
ip
0x1240
0x00
0x12
Types - pointers
EXAMPLES
int i, j, *ip;
ip = &i;
i = 22;
j = *ip; /* j now has the value 22 */
*ip = 17; /* i now has the value 17 */
Variables
i
Memory addresses
0x1200
Memory locations
0x16
0x00
0x1220
0x00
0x00
ip
0x1240
0x00
0x12
Types - pointers
EXAMPLES
int i, j, *ip;
ip = &i;
i = 22;
j = *ip; /* j now has the value 22 */
*ip = 17; /* i now has the value 17 */
Variables
i
Memory addresses
0x1200
Memory locations
0x16
0x00
0x1220
0x16
0x00
ip
0x1240
0x00
0x12
Types - pointers
EXAMPLES
int i, j, *ip;
ip = &i;
i = 22;
j = *ip; /* j now has the value 22 */
*ip = 17; /* i now has the value 17 */
Variables
i
Memory addresses
0x1200
Memory locations
0x11
0x00
0x1220
0x16
0x00
ip
0x1240
0x00
0x12
Types - pointers
The need for a generic data pointer that can be converted to any object pointer type arises
occasionally in low-level programming.
Standard C introduced the type void* as a "generic pointer
Type void* is considered to be neither an object pointer nor a function pointer
EXAMPLES
void *generic_ptr;
int *int_ptr;
char *char_ptr;
generic_ ptr = int_ptr; /* OK */
int_ptr = generic_ptr; /* OK */
int_ ptr = char_ ptr; /* invalid */
Int_ptr = (int*) char_ptr; /* OK */
void *memcpy(void *s1, const void *s2, size_t n);
Types - Arrays
If T is any C type except void or a function type, then the type "array of T" may be declared
The length of the array may be specified by any integer constant expression
Values of this type are sequences of elements of type T. All arrays are 0-origin.
These values, known as elements, can be individually selected by their position within the array
Subscripting or indexing is used to access a particular element
EXAMPLE
int A[3];
A[0] = 100;
A[1] = 200;
A[2] = 300;
is equivalent with
int A[3] = { 0x0064, 0x00C8, 0x012C };
Variables
A[0]
Memory addresses
0x1200
Memory locations
0x64
0x00
A[1]
0x1202
0xC8
0x00
A[2]
0x1204
0x2C
0x01
Types - Arrays
C doesnt require that subscript bounds to be checked; if a subscript goes out of range, the
programs behavior is undefined.
An array subscript may be an integer expression
The sizeof operator can determine the size of an array (in bytes); it returns a value equal with the product
between the length of the array and the length of one element.
EXAMPLE
int a[10], i;
for ( i = 0; i <= 10 ; i++ )
a[ i ] = 0;
Q: What is wrong with the code above?
Q: What is the value of sizeof operator
applied to array a?
Types - Arrays
In C there is a close correspondence between types "array of T " and "pointer to T":
When an array identifier appears in an expression, the type of the identifier is converted from
"array of T " to "pointer to T", and the value of the identifier is converted to a pointer to the first
element of the array
The only exceptions to this conversion rule is when the array identifier is used as an operand of
sizeof or address (&) operators, in which case sizeof returns the size of the entire array and &
returns a pointer to the array (not a pointer to a pointer to the first element)
Variables
EXAMPLE
A[0]
Memory addresses
0x1200
ip = &a[0];
0x00
0x00
int a[10], *ip;
ip = a;
It is exactly as :
Memory locations
ip
0x1214
0x00
0x12
Types - Arrays
In C there is a close correspondence between types "array of T " and "pointer to T":
array subscripting is defined in terms of pointer arithmetic. That is, the expression a [ i ] is
defined to be the same as * ((a) + (i)), where a is converted to &a [0]
a[i] is the same as ip[i]; so, any pointer may be subscripted just like an array
Variables
A[0]
Memory addresses
0x1200
i = ip[ 1 ]; /* i is equal with a[1] */
i = *(ip+2); /* i is equal with a[2] */
0x00
0x00
EXAMPLE
int a[10], *ip, i;
ip = a;
Memory locations
0x00
ip
0x1214
0x00
0x12
0x00
0x12
Types - Arrays
Multidimensional arrays are declared as arrays of arrays
The language places no limit on the number of dimensions an array may have
C stores the arrays in row-major order with row 0 first, then row 1 and so forth
The first dimension of an array may be left
empty
Variables
Memory addresses
A[0][0]
0x1200
EXAMPLE
*(a+1)
is a pointer to the first 3element subarray
is a pointer to the second
3-element subarray
is a pointer to the first integer in
that subarray.
*(a+1) +2
is a pointer to the third
integer in the second 3- element
subarray.
*(*(a+1) +2) is the third integer in the
second 3-element subarray
row 0
A[0][1]
A[0][2]
0x1204
0x02
0x00
0x1206
0x03
0x00
A[1][0]
0x1208
0x04
0x00
A[1][1]
row 1
a[1][2] is the same as *(*(a+1)+2)
a+1
0x01
0x00
int a[2][3] = { { 1, 2, 3 },
{ 4, 5, 6 } };
Memory locations
0x120A
0x05
0x00
A[1][2]
0x120C
0x06
0x00
Types
The type "function returning T " is a function type,
where T may be any type except "array of ... " or
"function returning ....
Functions may not return arrays or other functions,
although they can return pointers to arrays and
functions
Functions may be introduced in only two ways:
A function definition can create a function, define
its parameters and return value, and supply the
body of the function
EXAMPLE
extern int f(), (*fp) (int, int), (*apf [ ] ) (double);
i
i
A function declaration can introduce a reference
to a function object defined elsewhere
The only operations on an expression of function type
are converting it to a function pointer and calling it
fpl = f; /*
fp2 = &f; /*
int i, j, k;
i = f(14);
= (*fp) (j, k);
= (*apf [ j ])(k);
extern int f () ;
int (*fpl) (), (*fp2) ();
implicit conversion to
explicit manufacture of
pointer */
a pointer */
Types - void
The type void has no values and no operations
Type void is used:
as the return type of a function, signifying that the function returns no value
in a cast expression when it is desired to explicitly discard a value
to form the type void *, a "universal" data pointer
in place of the parameter list in a function declarator to indicate that the function takes no arguments
EXAMPLE
void main( void )
void func( int i )
int func( void )
(void)(x++ || y--);
void *memcpy(void *s1, const void *s2, size_t n);
Conversions
The C language provides for values of one type to be converted to values of other types under several
circumstances:
A cast expression may be used to explicitly convert a value to another type
An operand may be implicitly converted to another type in preparation for performing some arithmetic or
logical operation
An object of one type may be assigned to a location (lvalue) of another type, causing an implicit type
conversion
An actual argument to a function may be implicitly converted to another type prior to the function call
A return value from a function may be implicitly converted to another type prior to the function return
Conversions
When two values must be operated on in combination, they are first converted
according to the usual binary conversions to a single common type, which is
also typically the type of the result
Usual binary conversions (choose first that applies)
If either operand has type
And the other operand has type
Standard C converts both to
long double
any real type
long double
double
any real type
double
float
any real type
float
any unsigned type
any unsigned type
the unsigned type with the greater rank
any signed type
any signed type
the signed type with the greater rank
any unsigned type
any signed type of less or equal rank
the unsigned type
any unsigned type
a signed type of greater rank that can
represent all values of the unsigned type
the signed type
any unsigned type
a signed type of greater rank that cannot
represent all values of the unsigned type
the unsigned version of the signed type
any other type
any other type
(no conversion)
C Keywords
