C
LANGUAGE HISTORY
A high-level programming language developed by Dennis Ritchie at Bell
Labs in the mid 1970s. Although originally designed as a systems programming language, C
has proved to be a powerful and flexible language that
can be used for a variety of applications, from business programs to engineering.
C is a particularly
popular language for personal computer programmers because it is relatively small -- it requires
less memory than other languages.
The first major program written in C was
the UNIX operating system, and
for many years C was considered to be inextricably linked with UNIX. Now,
however, C is an important language independent of UNIX.
Although it is a high-level language, C
is much closer to assembly language than are most other high-level languages.
This closeness to the underlying machine language allows C programmers to write very
efficient code.
Where is C useful?
C’s ability to communicate directly with hardware makes
it a powerful choice for system programmers. In fact, popular operating systems
such as Unix and Linux are written entirely in C. Additionally, even compilers
and interpreters for other languages such as FORTRAN, Pascal, and BASIC are
written in C. However, C’s scope is not just limited to developing system
programs. It is also used to develop any kind of application, including complex
business ones. The following is a partial list of areas where C language is
used:
- Embedded Systems
- Systems Programming
- Artificial Intelligence
- Industrial Automation
- Computer Graphics
- Space Research
- Image Processing
- Game Programming
What
kind of language is C?
C is a structured programming language, which means that
it allows you to develop programs using well-defined control structures, and
provides modularity (breaking the task into multiple sub tasks
that are simple enough to understand and to reuse).
C is often called a middle-level language because it
combines the best elements of low-level or machine language with high-level
languages.
Why you should learn
C?
- C is simple.
- There are only 32 keywords so C is very easy to master. Keywords are words that have special meaning in C language.
- C programs run faster than programs written in most other languages.
- C enables easy communication with computer hardware making it easy to write system programs such as compilers and interpreters.
A C program basically has the following form:
- Preprocessor
Commands
- Functions
- Variables
- Statements
& Expressions
- Comments
The following program is written in the C
programming language. Open a text file hello.c using vi
editor and put the following lines inside that file.
|
#include
int main()
{
/* My first program */
printf("Hello, World! \n");
return 0;
}
|
Preprocessor Commands:
These commands tells
the compiler to do preprocessing before doing actual compilation. Like #include
Functions:
It is the main building blocks of
any C Program. Every C Program will have one or more functions and there is one
mandatory function which is called main() function. This
function is prefixed with keyword int which means this
function returns an integer value when it exits. This integer value is retured
using return statement.
The C Programming language provides a set of
built-in functions. In the above example printf()is a C built-in
function which is used to print anything on the screen. Check Built in function section for more detail.
Variables:
These are used to hold numbers, strings and
complex data for manipulation.
Statements & Expressions :
Expressions combine
variables and constants to create new values. Statements are expressions,
assignments, function calls, or control flow statements which make up C
programs.
These are used to give
additional useful information inside a C Program. All the comments will be put
inside /*...*/ as given in the example above. A comment can span through
multiple lines.
float - data type
double - data type
char - data type
Modifiers
What this means is that a 'short int' should assign less than or the same amount of storage as an 'int' and the 'int' should be less or the same bytes than a 'long int'. What this means in the real world is:
A type qualifier is used to refine the declaration of a variable, a function, and parameters, by specifying whether:Qualifiers
The number of initializers cannot be more than the number of elements in the array but it can be less in which case, the remaining elements are initialized to 0.if you like, the array size can be inferred from the number of initializers by leaving the square brackets empty so these are identical declarations:
An array of characters ie string can be initialized as follows:
Here ++ is called incremental operator and it increase the value of any integer variable by 1. Thus i++ is equivalent to i = i + 1;
If same variable name is being used for global and local variable then local variable takes preference in its scope. But it is not a good practice to use global variables and local variables with the same name.
i in main function is global and will be incremented to 5. i in func is internal and will be incremented to 11. When control returns to main the internal variable will die and and any reference to i will be to the global.
The example above defines two variables with the same storage class. auto can only be used within functions, i.e. local variables.
register - Storage Class
static - Storage Class
NOTE : Here keyword void means function does not return anything and it does not take any parameter. static variables are initialized to 0 automatically.
Now, 'func' returns a pointer to the memory location where 'text2' starts BUT text2 has a storage class of 'auto' and will disappear when we exit the function and could be overwritten but something else. The answer is to specify
The storage assigned to 'text2' will remain reserved for the duration if the program.
extern - Storage Class
There are following arithmetic operators supported by C language:
Logical (or Relational) Operators:
Show Examples
Bitwise Operators:
Assignment Operators:
Short Notes on L-VALUE and R-VALUE:
Characteristics
of C
C's characteristics that define the language and also have
lead to its popularity as a programming language.
- Small size
- Extensive use of function calls
- Loose typing -- unlike PASCAL
- Structured language
- Low level (BitWise) programming readily available
- Pointer implementation - extensive use of pointers for memory, array, structures and functions.
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.
C
Program Structure
- A C program basically has the following form:
- Preprocessor Commands
- Type definitions
- Function prototypes -- declare function types and variables passed to function.
- Variables
- Functions
- We must have a main() function.
A
function has the form:
type function_name (parameters)
{
local variables
C Statements
}
If
the type definition is omitted C assumes that function returns an integer type. NOTE: This
can be a source of problems in a program.
So
returning to our first C program:
/* Sample
program */
main()
{
printf( ``I Like C n''
);
exit ( 0 );
}
C has a concept of 'data types' which are
used to define a variable before its use. The definition of a variable will
assign storage for the variable and define the type of data that will be held
in the location.
The value of a variable can be changed any
time.
C has the following basic built-in datatypes.
- int
- float
- double
- char
int - data type
int is used to define
integer numbers.
{
int Count;
Count = 5;
}
|
float - data type
float is used to define
floating point numbers.
{
float Miles;
Miles = 5.6;
}
|
double - data type
double is used to define BIG
floating point numbers. It reserves twice the storage for the number. On PCs
this is likely to be 8 bytes.
{
double Atoms;
Atoms = 2500000;
}
|
char - data type
char defines characters.
{
char Letter;
Letter = 'x';
}
|
Modifiers
The data types explained above have the
following modifiers.
- short
- long
- signed
- unsigned
The modifiers define the amount of storage
allocated to the variable. The amount of storage allocated is not cast in
stone. ANSI has the following rules:
short int <= int <= long int
float <= double <= long
double
|
What this means is that a 'short int' should assign less than or the same amount of storage as an 'int' and the 'int' should be less or the same bytes than a 'long int'. What this means in the real world is:
Type Bytes Range
|
short int 2
-32,768 -> +32,767 (32kb)
unsigned short int 2 0 -> +65,535 (64Kb)
unsigned int 4 0 -> +4,294,967,295 ( 4Gb)
int 4
-2,147,483,648 -> +2,147,483,647 ( 2Gb)
long int 4
-2,147,483,648 -> +2,147,483,647 ( 2Gb)
signed char 1 -128 -> +127
unsigned char 1 0 -> +255
float 4
double 8
long double 12
|
A type qualifier is used to refine the declaration of a variable, a function, and parameters, by specifying whether:Qualifiers
- The value
of a variable can be changed.
- The value
of a variable must always be read from memory rather than from a register
Standard C language recognizes the following
two qualifiers:
- const
- volatile
The const qualifier is used
to tell C that the variable value can not change after initialisation.
const float pi=3.14159;
Now pi cannot be changed at
a later time within the program.
Another way to define constants is with
the #define preprocessor which has the advantage that it does
not use any storage
The volatile qualifier declares a data type
that can have its value changed in ways outside the control or detection of the
compiler (such as a variable updated by the system clock or by another
program). This prevents the compiler from optimizing code referring to the
object by storing the object's value in a register and re-reading it from
there, rather than from memory, where it may have changed. You will use this
qualifier once you will become expert in "C". So for now just
proceed.
Array Initialization
- As with
other declarations, array declarations can include an optional
initialization
- Scalar
variables are initialized with a single value
- Arrays are
initialized with a list of values
- The list
is enclosed in curly braces
int array [8] = {2, 4, 6,
8, 10, 12, 14, 16};
|
The number of initializers cannot be more than the number of elements in the array but it can be less in which case, the remaining elements are initialized to 0.if you like, the array size can be inferred from the number of initializers by leaving the square brackets empty so these are identical declarations:
int array1 [8] = {2, 4,
6, 8, 10, 12, 14, 16};
int array2 [] = {2, 4, 6,
8, 10, 12, 14, 16};
|
An array of characters ie string can be initialized as follows:
char string[10] =
"Hello";
|
A variable is just a named area of storage
that can hold a single value (numeric or character). The C language demands
that you declare the name of each variable that you are going to use and its
type, or class, before you actually try to do anything with it.
The Programming language C has two main
variable types
- Local Variables
- Global Variables
Local Variables
- Local variables scope is confined within the block
or function where it is defined. Local variables must always be defined at
the top of a block.
- When a local variable is defined - it is not
initalised by the system, you must initalise it yourself.
- When execution of the block starts the variable is
available, and when the block ends the variable 'dies'.
Check following example's output
main()
{
int i=4;
int j=10;
i++;
if (j > 0)
{
/* i defined in 'main' can be seen
*/
printf("i is %d\n",i);
}
if (j > 0)
{
/* 'i' is defined and so local to
this block */
int i=100;
printf("i is
%d\n",i);
}/* 'i' (value 100) dies here */
printf("i is %d\n",i); /* 'i'
(value 5) is now visable.*/
}
This will generate following output
i is 5
i is 100
i is 5
|
Here ++ is called incremental operator and it increase the value of any integer variable by 1. Thus i++ is equivalent to i = i + 1;
You will see -- operator
also which is called decremental operator and it i decrease the value of any
integer variable by 1. Thus i-- is equivalent to i = i
- 1;
Global Variables
Global variable is defined at the top of the
program file and it can be visible and modified by any function that may
reference it.
Global variables are initalised automatically
by the system when you define them!
Data Type
|
Initialser
|
int
|
0
|
char
|
'\0'
|
float
|
0
|
pointer
|
NULL
|
If same variable name is being used for global and local variable then local variable takes preference in its scope. But it is not a good practice to use global variables and local variables with the same name.
int i=4; /* Global definition */
main()
{
i++; /* Global variable */
func();
printf( "Value of i = %d -- main
function\n", i );
}
func()
{
int i=10; /* Local definition */
i++; /* Local variable */
printf( "Value of i = %d --
func() function\n", i );
}
This will produce following result
Value of i = 11 -- func() function
Value of i = 5 -- main function
|
i in main function is global and will be incremented to 5. i in func is internal and will be incremented to 11. When control returns to main the internal variable will die and and any reference to i will be to the global.
A storage class defines the scope
(visibility) and life time of variables and/or functions within a C Program.
There are following storage classes which can
be used in a C Program
- auto
- register
- static
- extern
auto - Storage Class
auto is the default
storage class for all local variables.
{
int Count;
auto int Month;
}
|
The example above defines two variables with the same storage class. auto can only be used within functions, i.e. local variables.
register - Storage Class
register is used to define
local variables that should be stored in a register instead of RAM. This means
that the variable has a maximum size equal to the register size (usually one
word) and cant have the unary '&' operator applied to it (as it does not
have a memory location).
{
register int Miles;
}
|
Register should only be used for variables
that require quick access - such as counters. It should also be noted that
defining 'register' goes not mean that the variable will be stored in a
register. It means that it MIGHT be stored in a register - depending on hardware
and implimentation restrictions.
static - Storage Class
static is the default
storage class for global variables. The two variables below (count and road)
both have a static storage class.
static int Count;
int Road;
{
printf("%d\n", Road);
}
|
static variables can be 'seen' within all
functions in this source file. At link time, the static variables defined here
will not be seen by the object modules that are brought in.
static can also be defined within a function.
If this is done the variable is initalised at run time but is not reinitalized
when the function is called. This inside a function static variable retains its
value during vairous calls.
void func(void);
static count=10; /* Global variable -
static is the default */
main()
{
while (count--)
{
func();
}
}
void func( void )
{
static i = 5;
i++;
printf("i is %d and count is
%d\n", i, count);
}
This will produce following result
i is 6 and count is 9
i is 7 and count is 8
i is 8 and count is 7
i is 9 and count is 6
i is 10 and count is 5
i is 11 and count is 4
i is 12 and count is 3
i is 13 and count is 2
i is 14 and count is 1
i is 15 and count is 0
|
NOTE : Here keyword void means function does not return anything and it does not take any parameter. static variables are initialized to 0 automatically.
Definition vs Declaration : Before proceeding,
let us understand the difference between defintion and declaration of
a variable or function. Definition means where a variable or function is
defined in reality and actual memory is allocated for variable or function.
Declaration means just giving a reference of a variable and function. Through
declaration we assure to the complier that this variable or function has been
defined somewhere else in the program and will be provided at the time of
linking. In the above examples char *func(void) has been put
at the top which is a declaration of this function where as this function has
been defined below to main()function.
There is one more very important use for
'static'. Consider this bit of code.
char *func(void);
main()
{
char *Text1;
Text1 = func();
}
char *func(void)
{
char Text2[10]="martin";
return(Text2);
}
|
Now, 'func' returns a pointer to the memory location where 'text2' starts BUT text2 has a storage class of 'auto' and will disappear when we exit the function and could be overwritten but something else. The answer is to specify
static char Text[10]="martin";
|
The storage assigned to 'text2' will remain reserved for the duration if the program.
extern - Storage Class
extern is used to give a
reference of a global variable that is visible to ALL the program files. When
you use 'extern' the variable cannot be initalized as all it does is point the
variable name at a storage location that has been previously defined.
When you have multiple files and you define a
global variable or function which will be used in other files also, then extern will
be used in another file to give reference of defined variable or function. Just
for understanding extern is used to decalre a global variable
or function in another files.
File 1: main.c
int count=5;
main()
{
write_extern();
}
|
File 2: write.c
void write_extern(void);
extern int count;
void write_extern(void)
{
printf("count is %i\n",
count);
}
|
Here extern keyword is being
used to declare count in another file.
What is Operator?
Simple answer can be given using expression 4 + 5 is equal to 9. Here 4 and 5 are called operands and + is called operator. C language supports following type of operators.
Simple answer can be given using expression 4 + 5 is equal to 9. Here 4 and 5 are called operands and + is called operator. C language supports following type of operators.
- Arithmetic Operators
- Logical (or Relational) Operators
- Bitwise Operators
- Assignment Operators
- Misc Operators
Arithmetic Operators:
There are following arithmetic operators supported by C language:
Assume variable A holds 10 and variable B
holds 20 then:
Operator
|
Description
|
Example
|
+
|
Adds
two operands
|
A
+ B will give 30
|
-
|
Subtracts
second operand from the first
|
A
- B will give -10
|
*
|
Multiply
both operands
|
A
* B will give 200
|
/
|
Divide
numerator by denumerator
|
B
/ A will give 2
|
%
|
Modulus
Operator and remainder of after an integer division
|
B
% A will give 0
|
++
|
Increment
operator, increases integer value by one
|
A++
will give 11
|
--
|
Decrement
operator, decreases integer value by one
|
A--
will give 9
|
Logical (or Relational) Operators:
There are following logical operators
supported by C language
Assume variable A holds 10 and variable B
holds 20 then:
Show Examples
Operator
|
Description
|
Example
|
==
|
Checks
if the value of two operands is equal or not, if yes then condition becomes
true.
|
(A
== B) is not true.
|
!=
|
Checks
if the value of two operands is equal or not, if values are not equal then
condition becomes true.
|
(A
!= B) is true.
|
>
|
Checks
if the value of left operand is greater than the value of right operand, if
yes then condition becomes true.
|
(A
> B) is not true.
|
<
|
Checks
if the value of left operand is less than the value of right operand, if yes
then condition becomes true.
|
(A
< B) is true.
|
>=
|
Checks
if the value of left operand is greater than or equal to the value of right
operand, if yes then condition becomes true.
|
(A
>= B) is not true.
|
<=
|
Checks
if the value of left operand is less than or equal to the value of right
operand, if yes then condition becomes true.
|
(A
<= B) is true.
|
&&
|
Called
Logical AND operator. If both the operands are non zero then then condition
becomes true.
|
(A
&& B) is true.
|
||
|
Called
Logical OR Operator. If any of the two operands is non zero then then
condition becomes true.
|
(A
|| B) is true.
|
!
|
Called
Logical NOT Operator. Use to reverses the logical state of its operand. If a
condition is true then Logical NOT operator will make false.
|
!(A
&& B) is false.
|
Bitwise Operators:
Bitwise operator works on bits and perform
bit by bit operation.
Assume if A = 60; and B = 13; Now in binary
format they will be as follows:
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011
Show Examples
There are following Bitwise operators
supported by C language
Operator
|
Description
|
Example
|
&
|
Binary
AND Operator copies a bit to the result if it exists in both operands.
|
(A
& B) will give 12 which is 0000 1100
|
|
|
Binary
OR Operator copies a bit if it exists in eather operand.
|
(A
| B) will give 61 which is 0011 1101
|
^
|
Binary
XOR Operator copies the bit if it is set in one operand but not both.
|
(A
^ B) will give 49 which is 0011 0001
|
~
|
Binary
Ones Complement Operator is unary and has the efect of 'flipping' bits.
|
(~A
) will give -60 which is 1100 0011
|
<<
|
Binary
Left Shift Operator. The left operands value is moved left by the number of
bits specified by the right operand.
|
A
<< 2 will give 240 which is 1111 0000
|
>>
|
Binary
Right Shift Operator. The left operands value is moved right by the number of
bits specified by the right operand.
|
A
>> 2 will give 15 which is 0000 1111
|
Assignment Operators:
There are following assignment operators
supported by C language:
Operator
|
Description
|
Example
|
=
|
Simple
assignment operator, Assigns values from right side operands to left side
operand
|
C
= A + B will assigne value of A + B into C
|
+=
|
Add
AND assignment operator, It adds right operand to the left operand and assign
the result to left operand
|
C
+= A is equivalent to C = C + A
|
-=
|
Subtract
AND assignment operator, It subtracts right operand from the left operand and
assign the result to left operand
|
C
-= A is equivalent to C = C - A
|
*=
|
Multiply
AND assignment operator, It multiplies right operand with the left operand
and assign the result to left operand
|
C
*= A is equivalent to C = C * A
|
/=
|
Divide
AND assignment operator, It divides left operand with the right operand and
assign the result to left operand
|
C
/= A is equivalent to C = C / A
|
%=
|
Modulus
AND assignment operator, It takes modulus using two operands and assign the
result to left operand
|
C
%= A is equivalent to C = C % A
|
<<=
|
Left
shift AND assignment operator
|
C
<<= 2 is same as C = C << 2
|
>>=
|
Right
shift AND assignment operator
|
C
>>= 2 is same as C = C >> 2
|
&=
|
Bitwise
AND assignment operator
|
C
&= 2 is same as C = C & 2
|
^=
|
bitwise
exclusive OR and assignment operator
|
C
^= 2 is same as C = C ^ 2
|
|=
|
bitwise
inclusive OR and assignment operator
|
C
|= 2 is same as C = C | 2
|
Short Notes on L-VALUE and R-VALUE:
x = 1; takes the value on the right (e.g. 1)
and puts it in the memory referenced by x. Here x and 1 are known as L-VALUES
and R-VALUES respectively L-values can be on either side of the assignment
operator where as R-values only appear on the right.
So x is an L-value because it can appear on
the left as we've just seen, or on the right like this: y = x; However,
constants like 1 are R-values because 1 could appear on the right, but 1 = x;
is invalid.
Misc Operators
There are few other operators supported by C
Language.
Operator
|
Description
|
Example
|
sizeof()
|
Returns
the size of an variable.
|
sizeof(a),
where a is interger, will return 4.
|
&
|
Returns
the address of an variable.
|
&a;
will give actaul address of the variable.
|
*
|
Pointer
to a variable.
|
*a;
will pointer to a variable.
|
?
:
|
Conditional
Expression
|
If
Condition is true ? Then value X : Otherwise value Y
|
Operators Categories:
All the operators we have discussed above can
be categorised into following categories:
- Postfix operators, which follow a single operand.
- Unary prefix operators, which precede a single operand.
- Binary operators, which take two operands and perform a variety of arithmetic and logical operations.
- The conditional operator (a ternary operator), which takes three operands and evaluates either the second or third expression, depending on the evaluation of the first expression.
- Assignment operators, which assign a value to a variable.
- The comma operator, which guarantees left-to-right evaluation of comma-separated expressions.
Precedence of C Operators:
Operator precedence determines the grouping
of terms in an expression. This affects how an expression is evaluated. Certain
operators have higher precedence than others; for example, the multiplication
operator has higher precedence than the addition operator:
For example x = 7 + 3 * 2; Here x is assigned
13, not 20 because operator * has higher precedenace than + so it first get
multiplied with 3*2 and then adds into 7.
Here operators with the highest precedence
appear at the top of the table, those with the lowest appear at the bottom.
Within an expression, higher precedenace operators will be evaluated first.
Category
|
Operator
|
Associativity
|
Postfix
|
()
[] -> . ++ - -
|
Left
to right
|
Unary
|
+
- ! ~ ++ - - (type) * & sizeof
|
Right
to left
|
Multiplicative
|
*
/ %
|
Left
to right
|
Additive
|
+
-
|
Left
to right
|
Shift
|
<<
>>
|
Left
to right
|
Relational
|
<
<= > >=
|
Left
to right
|
Equality
|
==
!=
|
Left
to right
|
Bitwise
AND
|
&
|
Left
to right
|
Bitwise
XOR
|
^
|
Left
to right
|
Bitwise
OR
|
|
|
Left
to right
|
Logical
AND
|
&&
|
Left
to right
|
Logical
OR
|
||
|
Left
to right
|
Conditional
|
?:
|
Right
to left
|
Assignment
|
=
+= -= *= /= %= >>= <<= &= ^= |=
|
Right
to left
|
Comma
|
,
|
Left
to right
|
