In 1972, C was developed at Bell Laboratories by Dennis Ritchie.

C is a simple programming language with a relatively simple to understand syntax and few
keywords.
C is useless.C itself has no input/output commands, doesn't have support for strings as a
fundamental data type. There is no useful math functions built in.
C requires the use of libraries as C is useless by itself. This increases the complexity of the
C.The use of ANSI libraries and other methods,the issue of standard libraries is resolved.
C Programming :: A Quick Hellow World Program
Let's give a simple program that prints out "Hello World" to standard out. We'll call our
program as hello.c.

#include <stdio.h>
main() {
printf("Hello, world!\n");
return 0;
}

Explanation of The Above Code:

#include <stdio.h> -This line tells the compiler to include this header file for compilation.

What is header file?They contain prototypes and other compiler/pre-processor

directive.Prototypes are also called the basic abstract function definitions.
Some common header files are stdio.h,stdlib.h, unistd.h and math.h.
main()- This is a function, in particular it is the main block.

{ } - These curly braces are equivalent to the stating that "block begin" and "block end".These
can be used at many places,such as switch and if statement.

printf() - This is the actual print statement which is used in our c program fraquently.we have
header file stdio.h! But what it does? How it is defined?

return 0-What is this? Who knows what is this

Seems like trying to figure out all this is just way too confusing.

Then the return 0 statement. Seems like we are trying to give something back, and it gives the
result as an integer. Maybe if we modified our main function definition: int main() ,now we are
saying that our main function will be returning an integer!So,you should always explicitly
declare the return type on the function.

Let us add #include <stdlib.h> to our includes. Let's change our original return statement to
return EXIT_SUCCESS;. Now it makes sense!
printf always returns an int. The main pages say that printf returns the number of characters
printed.It is good programming practice to check for return values. It will not only make your
program more readable, but at the end it will make your programs less error prone. But we
don't really need it in this particular case.So we cast the function's return to (void). fprintf,exit
and fflush are the only functions where you should do this.

What about the documentation? We should probably document some of our code so
that other people can understand what we are doing. Comments in the C89 standard are noted
by this: /* */. The comment always begins with /* and ends with */.

An Improved Code of The Above Example

#include <stdio.h> #include <stdlib.h>

/* Main Function
* Purpose: Controls our program, prints Hello, World!
* Input: None
* Output: Returns Exit Status
*/
int main() {
(void)printf("Hello, world!\n");
return EXIT_SUCCESS;
}

Note:

The KEY POINT of this whole introduction is to show you the fundamental difference
between understandability and correctness. If you lose understandability in an attempt to gain
correctness, you will lose at the end. Always place the understandability as a priority ABOVE
correctness. If a program is more understandable in the end,the chances it can be fixed
correctly will be much higher. It is recommend that you should always document your
program. You stand less of a chance of screwing up your program later,if you try to make your
program itself more understandable.

The advantages of C
In other words,for writing anything from small programs for personal amusement to complex
industrial applications,C is one of a large number of high-level languages designed for general-
purpose programming.

C has many advantages:

1) Before C,machine-language programmers criticized high-level languages because,with
their black box approach,they shielded the user from the working details of all its facilities and
the computer. To give access to any level of the computer down to raw machine
language,however, C was designed and because of this, it is perhaps the most flexible high-
level language.
2) To organize programs in a clear,easy,logical way,C has features that allow the
programmer.For example,C allows meaningful names for variables without any loss of
efficiency, yet it gives a complete freedom of programming style,a set of flexible commands
for performing tasks repetitively (for, while,do) and including flexible ways of making
decisions.
3) C is also succinct. It permits the creation of tidy and compact programs. This feature can be
a mixed blessing, however, and the C programmer must balance readability and simplicity.
4) C allows commands that are invalid in some other languages. This is no defect, but a
powerful freedom which, when used with caution, makes many things easily possible. It does
mean that there are concealed difficulties in C, but if you write thoughtfully and carefully, you
can create fast, efficient programs.
5) With C, you can use every resource of your computer offers. C tries to link closely with the
local environment, providing facilities for gaining access to common peripherals like printers
and disk drives.

The C Compilation Model

Creating, Compiling and Running Your Program
Creating the program
First create a file containing the complete program, such as the above example. You can use
any ordinary editor to create the file. One such editor is textedit which is available on most
UNIX systems.
The filename must have extension ``.c'' (full stop, lower case c), e.g. myprog.c or progtest.c.
The contents must have to obey C syntax. For example, they might be as in the above
example,starting with the line /* /* end of the program */.
Compilation
There are many C compilers are present around. The cc is being the default Sun compiler. The
GNU C compiler gcc is popular and also available for many platforms. PC users may also be
familiar with Borland bcc compiler.
There are also C++ compilers which are usually denoted by CC (note upper case CC.For
example Sun provides GNU and CCGCC. The GNU compiler is also denoted by the command
g++
Other C/C++ compilers also exist. All the above compilers operate in essentially the share
many common command line options and same manner. However, the best source of each
compiler is through online manual pages of your system: e.g. man cc.
In the basic discussions of compiler operation,for the sake of compactness,we will simply refer
to the cc compiler -- other compilers can simply be substituted in place of cc until and unless
otherwise stated.
Your program simply invoke the command cc to Compile . The command must be followed by
the name of the (C) program you wish to compile it.
The compilation command is:
cc program.c
where program.c is name of the file.
If there are obvious errors in your program (such as mistypings, misspelling one of the key
words or omitting a semi-colon), the compiler will detect it and report them.
It may possible that the compiler cannot detect logical errors.
If the compiler option -o is used : the file listed after the -oor when the compiler has
successfully digested your program, the compiled version, or executable, is left in a file called
a.out
It is convenient to use a -o and filename in the compilation as in
cc -o program program.c

which puts the compiled program into the file program ( any file you name following the "-o"
argument) instead of putting it in the file a.out .
Running the program
The next stage is to run your executable program.You simply type the name of the file
containing it, in this case program (or a.out),to run an executable in UNIX.
This executes your program able to print any results to the screen. At this stage there may be
run-time errors, such as it may become evident that the program has produced incorrect output
or division by zero.
If so, you must return to edit your program source, and compile it again, and run it again.
C is a High Level Language
C is also called as a high-level language. To give a list of instructions (a computer program) to
a computer,the high-level computer language is used. The native language of the computer is a
stream of numbers called machine level language. As you might expect, the action resulting
from a single machine language instruction is very primitive, and many thousands of them can
be required to do something like substantial. A high-level language provides a set of
instructions you can recombine creatively and give to the imaginary black boxe of the
computer. The high-level language software will then translate these high-level instructions
into the low-level machine language instructions

Characteristics of C
We briefly list some of C's characteristics that have lead to its popularity as a programming
language and define the language. Naturally we will be studying many of these aspects
throughout our tutorial.

• Extensive use of function calls

• Small size
• 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 produces efficient programs.
• It can handle low-level activities.
• It can be compiled on a variety of computers.

The main drawback of c is that it has poor error detection which can make it off putting to the
beginner. However diligence in this matter can pay off handsomely since having learned the
rules of the C we can break them. Not all languages allow this. This if done carefully and
properly leads to the power of C programming.

C Program Structure
A C program basically has the following form:

• Preprocessor Commands
• Function prototypes -- declare function types and variables passed to function.
• Type definitions
• Variables
• Functions

We must have a main() function

C assumes that function returns an integer type,if the type definition is omitted. NOTE: This
can be a source of the problems in a program

/* Sample program */
main()
{
printf( ``I Like C \n'' );
exit ( 0 );
}

NOTE:
• printf is a standard C function -- called from main.
• C requires a semicolon at the end of the every statement.
• \n signifies newline. Formatted output -- more later.
• exit() is also a standard function that causes the program to terminate. Strictly speaking
it is not needed here as it is the last line of main() and the program will terminate
anyway.

C has the following simple data types

Variables in C

1. Variables in C are memory locations with help of which we can be assigned values and
are given names .
2. To store data in memory for later use,we use variables.
3. In C, a variable must have to be declared before it can be used.
4. You can declare Variables at the start of any block of code, but most are found at the
start of each function.
5. Most local variables are destroyed on return from that function and created when the
function is called.
6. A declaration begins with the type, followed by the name of one or more than one
variables.
The following code describe the declaration of variable:
int main()
{
int a;
char b;
return 0;
}

C keeps a small set of keywords for its own use only.These keywords are given below:
auto break case char const continue default do
double else enum extern float for goto if
int long register return short signed sizeof static
struct switch typedef union unsigned void volatile while

Identifiers in C
Identifiers" or "symbols" are the names you supply for variables, types,labels, and functions in
your program. Identifier names must differ in case and spelling from any keywords. You
cannot use keywords as the identifiers; they are reserved for special use only. You create an
identifier by specifying it in the declaration of a variable,function,or type. In this example
which is given below result is an identifier for an integer variable, and printf and main are
identifier names for functions.

Identifiers provide names for the given language elements:

• Functions
• Function parameters
• Macros and macro parameters
• Type definitions
• Objects
• Labels
• Enumerated types and enumerators
• Structure and union names

#include <stdio.h>
int main()
{
int result;
if ( result != 0 )
printf_s( "Bad file handle\n" );
}
Variable declarations
Variables are of three different types which are as follows:

• Global Variable
• Local Variable
• Static Variable

Global Variable:
These variables can be accessed by any function of the program. By associating memory
locations with variable names,they are implemented. If the function is recalled,they do not get
recreated . Declare it outside of all the functions if you want to declare a global variable. The
function will use the variable that was declared within it and ignore the global one,if a variable
of the same name is declared both within a function and outside of it.
Local Variable:
Inside the specific function that creates them,these variables only exist. They are unknown to
to the main program and to the other functions. In this case,they are normally implemented
using a stack. Local variables cease to exist once if the function that created them is completed.
Each time a function is executed or called,they are recreated.

Variable declarations show up in three places:

• Outside a function. These declarations declare global variables which are visible
throughout the program (i.e. they have global scope). Use of global variables is always
a big mistake.

• In the header of a function in the argument list . These variables are the parameters to
the function. They are only visible inside the function body and their local scope), exist
only from when the function is called to when the function returns (bounded extent---
note that this is different from what happens in some garbage-collected languages like
Scheme), and get their initial values from the arguments to the function when it is
called.

• At the start of any block delimited by curly braces only. Such variables are exist only
when the containing function is active (bounded extent) and visible only within the
block (local scope again). The convention in C is generally to declare all such local
variables at the top of a function; this is different from the convention in C++ or Java,
which encourage variables to be declared when they are first time used

The following program demonstrate the use of global and local variables.

#include <stdio.h>
int counter = 0; /* global because we are outside all blocks.*/
int func(void);
main()
{
counter++; /* global because it has not been declared within this block */
printf("counter is %2d before the call to func\n", counter);

func(); /* call a function. */

printf("counter is %2d after the call to func\n", counter);
}

int func(void)
{
int counter = 10; /* local variable because it has declared within this block */
*/ printf("counter is %2d within func\n", counter);
}

Using static variables

Another important feature of the variable scoping is the static variable. In a local function
scope,a static variable exists only , but it does not lose its value when program execution leaves
this scope. Consider the example which is given below:

#include <stdio.h>
main()
{
Test();
}
function Test()
{
int a = 0;
printf("a is %d within func\n", a)
a++;
}
Since every time the function is called it sets a to 0 and prints "0",this function is quite
useless . The a++ which increments the variable serves no purpose since as soon as the
function exits then a variable disappears. The a variable is declared static to make a useful
counting function which will not lose track of the current count:

#include <stdio.h>
main()
{
Test();
}
function Test()
{
static int a = 0;
printf("a is %d within func\n", a)
a++;
}

Basic types
There are 4 basic types of variable in C; they are: char, int, double and float

Type
Meaning
name
The most basic unit addressable by the machine; typically a single octet. This is
char
an integral type.
The most natural size of integer for the machine; typically a whole 16, 32 or 64
int
bit addressable word.
float A single-precision floating point value.
double A double-precision floating point value.

Overview of the C Operators

The C operators fall into the following categories:

• Postfix operators, which follow a single operand only.

• Unary prefix operators, which precede with a single operand.
• Binary operators, which take two operands and perform a variety of logical and
arithmetic 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 only.
• Assignment operators, which only assign a value to a variable.
• The comma operator, which gives guarantees left-to-right evaluation of comma-
separated expressions.

To create more complex expressions,variables and constants can be used in conjunction with C
operators. The following tables describes different operators available in c
Operator Example Description/Meaning
() f() Function call
[] a[10] Array reference
-> <S->A td <> Structure and union member selection
. s.a Structure and union member selection
+ [unary] +a Value of a
- [unary] -a Negative of a
* [unary] *a Reference to object at address a
& [unary] &a Address of a
~ ~a One's complement of a
++ [prefix] ++a The value of a after increment
++ [postfix] a++ The value of a before increment
- - [prefix] -a The value of a after decrement
- - [postfix] a- The value of a before decrement
sizeof sizeof (t1) Size in bytes of object with type t1
sizeof sizeof e Size in bytes of object having the type of expression e
a+b a plus b
+ [binary]
a-b a minus b
- [binary]
a*b a times b
* [binary]
a/b a divided by b
/%
a%b Remainder of a/b
>> a >> b a, right-shifted b bits
<< a << b a, left-shifted b bits
< a<b 1 if a < b; 0 otherwise
> a>b 1 if a > b; 0 otherwise
<= a <= b 1 if a <= b; 0 otherwise
>= a >= b 1 if a >= b; 0 otherwise
== a == b 1 if a equal to b; 0 otherwise
!= a != b 1 if a not equal to b; 0 otherwise
& [binary] a&b Bitwise AND of a and b
| a|b Bitwise OR of a and b
^ a^b Bitwise XOR (exclusive OR) of a and b
&& a && b Logical AND of a and b (yields 0 or 1)
|| a || b Logical OR of a and b (yields 0 or 1)
! !a Logical NOT of a (yields 0 or 1)
?: a ? e1 : e2 Expression e1 if a is nonzero;
 Expression e2 if a is zero
= a=b a, after b is assigned to it
+= a += b a plus b (assigned to a)
-= a -= b a minus b (assigned to a)
*= a *= b a times b (assigned to a)
/= a /= b a divided by b (assigned to a)
%= a %= b Remainder of a/b (assigned to a)
>>= a >>= b a, right-shifted b bits (assigned to a)
<<= a <<= b a, left-shifted b bits (assigned to a)
&= a &= b a AND b (assigned to a)
|= a |= b a OR b (assigned to a)
^= a ^= b a XOR b (assigned to a)
, e1,e2 e2 (e1 evaluated first)

Precedence of C Operators

Precedence of C Operators

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
Branching
The C language programs follows a sequential form of execution of statements. Many times it
is required to alter the flow of sequence of instructions. C language provides statements that
can alter the flow of a sequence of instructions. These statements are called as control
statements. To jump from one part of the program to another,these statements help. The control
transfer may be unconditional or conditional. Branching Statemnt are of following categories:

• If Statement
• The If else Statement
• Compound Relational tests
• Nested if Statement
• Switch Statement
If Statement
If statement is the simplest form of the control statement. It is very frequently used in allowing
the flow of program execution and decision making.
The If structure has the following syntax
if(condition)

statement;

The command says that if the condition is true then perform the following statement or If the
condition is fake the computer skips the statement and moves on to the next instruction in the
program

The following program calculate the absolute value of an integer using if statement:
Calculate the absolute value of an integer */
# include < stdio.h > //Include the stdio.h file
void main ( ) // start of the program

{
int numbers; // Declare the variables
printf ("Type a number:"); // message to the user
scanf ("%d", & number); // read the number from standard input
if (number < 0) // check whether the number is a negative
number
number = - number; // If it is negative then convert it into
positive.
Printf ("The absolute value is % d \n", number); // print the value
}
The If else Statement
The if else is actually just an extension of the general format of if statement. If the result of the
condition is true, then program statement 1 is executed else program statement 2 will be
executed. The syntax of the If else statement is as follows:

If (condition)

Program statement 1;
Else
Program statement 2;

The following program find whether a number is negative or positive using if statement:

#include < stdio.h > //include the stdio.h header file in your program
void main ( ) // Start of the main
{
int num; // declare variable num as integer
printf ("Enter the number"); //message to the user
scanf ("%d", &num); // read the input number from keyboard
if (num < 0) // check whether number is less than zero.
Printf ("The number is negative") // If it is less than zero then it is negative.
Else // else statement.
Printf ("The number is positive"); //If it is more than zero then the given
number is positive.
}

Compound Relational tests

To perform compound relational tests,C language provides the necessary mechanisms. A
compound relational test is simple one or more simple relational tests joined together by either
the the logical OR operators or logical AND. These operators are represented by character
pairs && // respectively. To form complex expressions in C,the compound operators can be
used. The syntax of the Compound Relational tests is as follows:
a> if (condition1 && condition2 && condition3)
b>if (condition1 // condition2 // condition3)

Nested if Statement
The if statement may itself contain another if statement is called as nested if statement. The
syntax of the Nested if Statement is as follows
if (condition1)
if (condition2)
statement-1;
else
statement-2;
else
statement-3;
The following example print the given numbers along with the largest number using nested if
statement.

#include < stdio.h > //includes the stdio.h file to your program
main ( ) //start of main function
{
int a,b,c,big; //declaration of variables
printf ("Enter three numbers"); //message to the user
scanf ("%d %d %d", &a, &b, &c); //Read variables a,b,c,
if (a>b) // check whether a is greater than b if true then
if(a>c) // check whether a is greater than c
big = a ; // assign a to big
else big = c ; // assign c to big
else if (b>c) // if the condition (a>b) fails check whether b is
greater than c
big = b ; // assign b to big
else big = c ; // assign C to big
printf ("Largest of %d,%d&%d = %d", a,b,c,big);
}
//print the given numbers along with the largest number.

Switch Statement
The switch-case statement is a multi-way decision making statement. Unlike the multiple
decision statement that can be created using if-else, the switch statement evaluates the
conditional expression and tests it against the numerous constant values.During execution,the
branch corresponding to the value that the expression matches is taken.

The value of the expressions in a switch-case statement must have to be an ordinal type i.e.
integer, char, short, long, etc.Double and Float are not allowed.

The syntax of switch statement is as follows :

switch( expression )
{
case constant-expression1: statements1;
[case constant-expression2: statements2;]
[case constant-expression3: statements3;]
[default : statements4;]
}

O/P:
#include<stdio.h>
main()
{
int n=7;

switch(n) {
case 0:
printf("You typed zero.\n");
break;
case 3:
case 5:
case 7:
printf("n is a prime number\n");
break;
case 2: printf("n is a prime number\n");
case 4:
case 6:
case 8:
printf("n is an even number\n");
break;
case 1:
case 9:
printf("n is a perfect square\n");
break;
default:
printf("Only single-digit numbers are allowed\n");
break;
}
}

Looping
By using special loop keywords,you can loop (jumping for those assembly junkies) through
your code. These include following categories:
For loop
while loop
do while.

For Loop
The for statement allows for the controlled loop. The syntax for for loop is as follows:

for (start condition; continue condition; re-evaluation)

program statement;

The foollowing program shows the use of for loop which prints number from 0 to 10
* Sample program using a for statement */

#include <stdio.h>
int main(void)
{
int count;

for (count = 1; count <=10; count = count + 1)

printf("%d", count);

printf(\n);

return 0;
}
O/P:
1 2 3 4 5 6 7 8 9 10

While Loop
For repeating C statements whiles a condition is true,the while provides a the necessary
mechanism. The syntax for while loop is as follows:

while (condition)
program statement;

The foollowing program shows the use of while loop which prints number from 0 to 10
/* Sample program including the while loop */

#include <stdio.h>
int main(void)
{
int loop = 0;
while (loop <=10)
{
printf("%d", loop);
++loop
}

return 0;

}
The do while statement
The do {} while statement allows a loop to continue whilst a condition evaluates as TRUE
(non-zero value). The loop will exacute at least once The syntax is as follows

do {
/* do stuff */
} while (statement);

The following program reverse a number using do while loop

/* Demonstration of the do..while loop */

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

int value, r_digit;

printf(Enter a number to be reversed.\n);

scanf(%d, &value);

do
{
r_digit = value % 10;
printf("%d", r_digit);
value = value / 10;
} while (value != 0);
printf(\n);
return 0;
}

Difference between while and do while loop

The do statement is similar to the while statement except that its termination condition is at the
end of the body of the loop only. Thus, you want to use a do statement,if you want to perform
the body of the loop at least once, regardless of the condition.
Storage classes
Storage classes include following categories:
• auto
• extern
• register
• static.
auto
The auto keyword is used to place the specified variable into the stack area of memory. In most
variable declaration,this is usually implicit one, e.g. int i;
extern
The extern keyword is used to specify variable access the variable of the same name from
some other file. In modular programs,this is very useful for sharing variables.
register
The register keyword gives suggest to the compiler to place the particular variable in the fast
register memory located directly on the CPU. Most compilers these days (like gcc) are so smart
that suggesting registers could actually make your program more slower.
static
It is also used to declare the variables to be private to a certain file only when declared with
global variables. static can also be used with functions, making those functions visible only to
file itself.The static keyword is used for extending the lifetime of a particular variable. The
variable remains even after the function call is long gone (the variable is placed in the alterable
area of memory),if you declare a static variable inside a function,. The static keyword can be
overloaded.
The C Preprocessor is a separate step in the compilation process, but not part of the compiler.
C Preprocessor is just a text substitution tool and we'll refer to the C Preprocessor as the CPP.

The C Preprocessor
All preprocessor lines always begin with #. This listing is from Weiss pg. 104. The
unconditional directives are as follows:
• #define - Define a preprocessor macro
• #include - Insert a particular header from another file
• #undef - Undefine a preprocessor macro
• The conditional directives are as follows:
• #ifndef - If this macro is not defined
• #ifdef - If this macro is defined
• #if - Test if a compile time condition is true
• #elif - #else an #if in one statement
• #else - The alternative for #if
• #endif - End preprocessor conditional
Other directives include:
• ## - Token merge, creates a single token from two adjacent ones
• # - Stringization, replaces a macro parameter with a string constant

Some examples of the above is given below:

#define MAX_ARRAY_LENGTH 20
The above code will tell the CPP to replace instances of MAX_ARRAY_LENGTH with 20.
To increase readability,use #define for constants.
#include <stdio.h>
#include "mystring.h"

The above code tells the CPP to get stdio.h from System Libraries and add the text to this file.
The next line tells CPP to get mystring.h from the local directory and then add the text to the
file.

#undef MEANING_OF_LIFE
#define MEANING_OF_LIFE 42

The above code tells the CPP to undefine MEANING_OF_LIFE and define it for 42.

#ifndef IROCK
#define IROCK "You wish!"
#endif

The above code tells the CPP to define IROCK only if IROCK isn't defined already.
#ifdef DEBUG
/* Your debugging statements here */
#endif

Thed above code tells the CPP to do the following statements if DEBUG is defined.If you pass
the -DDEBUG flag to gcc,this is useful .

C File Handling - File Pointers

Use a new datatype called a file pointer to with C files . This type is written as FILE *, and
defined within stdio.h. A file pointer called output_file is declared in a statement is as follows:
FILE *output_file;
Function Name Operation
fopen() Creates a new file for use
Opens a new existing file for use
fclose Closes a file which has been opened for use
getc() Reads a character from
putc() Writes a character to a file
fprintf() Writes a set of data values to a file
fscanf() Reads a set of data values from a file
getw() Reads a integer from a file
putw() Writes an integer to the file
fseek() Sets the position to a desired point in the file
ftell() Gives the current position in the file
rewind() Sets the position to the begining of the file

Opening a file pointer using fopen()

To open streams,fopen() is used.For opening files for input, this is most often used. Before it
can access it,your program must open a file . This function returns the required file pointer.
The value NULL will be returned,if the file cannot be opened for any reason. fopen's prototype
is as follows:

FILE *fopen (const char *path, const char *mode);

fopen takes in the path to the file as well as the mode and to open the file with. Take for the
following example:

iFILE *Fp; Fp = fopen("/home/johndoe/input.dat", "r");

For reading,this will open the file in /home/johndoe/input.dat . You will usually use fopen as
given below:

if ((output_file = fopen("output_file", "w")) == NULL)

fprintf(stderr, "Cannot open %s\n", "output_file");

fopen takes two arguments, both are strings, the first is the name of the file to be opened, the
second is an access character, which is usually one of the following:
"r"-Opening the file for reading
"a"-Opening the file for appending
"w"-Opening the file for writing
"w+"-open for the writing and reading (existing file will be overwritten)
"r+"-open for the reading and updating (file must already exist)
"a+"-open for the appending and reading (file may or may not exist)

The following code fragmentis used to get the text from the first <title> element:
FILE *output_file;
Closing a file pointer using fclose()
You would use fclose() to close the stream, . The prototype for fclose is given below:

int fclose( FILE *stream );

File I/O :: fgets()

The alternatives to scanf/fscanf is fgets. The prototype is as follows:

char *fgets(char *s, int size, FILE *stream);

fgets stores it into *s pointer and reads in size - 1 characters from the stream. The string is
always automatically null-terminated. If it reaches an EOF or newline,fgets stops reading in
characters.

File I/O :: sscanf()

The sscanf library call is handy to scan a string for a format.The prototype is as follows:
int sscanf(const char *str, const char *format, ...);

sscanf takes a character pointer instead of a file pointer and works much like fscanf. Instead of
scanf/fscanf,using the combination of fgets/sscanf you can avoid the "digestion" problem (or
bug, depending on who you talk to :)

File I/O :: fprintf()

It is sometimes useful also to output to the different streams.
fprintf() allows us to do exactly the same thing
The prototype for fprintf is as follows:

int fprintf(FILE *stream, const char *format, ...);

fprintf takes in a special pointer called a file pointer, signified by the FILE *. It then accepts
argument and a formatting string and. The only difference between printf and fprintf is that
fprintf can redirect output to a particular stream. These streams can be stderr,stdout,or a file
pointer. More on the file pointers when we get to fopen. An example is given below:

fprintf(stderr, "ERROR: Cannot malloc enough memory.\n");

This output the error message to standard error.

File I/O :: fscanf()

fscanf() is basically a streams version of the scanf. The prototype for fscanf is as follows:

int fscanf( FILE *stream, const char *format, ...);

File I/O :: fflush()

If the program crashes, sometimes the stream isn't written. You can do this by using fflush()
function. Sometime it is necessary to forcefully flush a buffer to its stream. The prototype for
fflush is as follows:

int fflush(FILE *stream);

Not very difficult to use, specify the stream to fflush.

The program which is given below displays use of a file operations. The the program writes it
and data enter through the keyboard. Character by character, to file input. The end of the data
is indicated by entering an EOF character, which is control-z. the file input is closed at this
signal only.

#include< stdio.h >

main()
{
file *f1;
printf("Data input output");
f1=fopen(Input,w); /*Open the file Input*/
while((c=getchar())!=EOF) /*get a character from key board*/
putc(c,f1); /*write a character to input*/
fclose(f1); /*close the file input*/
printf("\nData output\n");
f1=fopen(INPUT,r); /*Reopen the file input*/
while((c=getc(f1))!=EOF)
printf("%c",c);
fclose(f1);
}

What is Pointer?
In c,a pointer is a variable that points to or references a memory location in which data is
stored. In the computer,each memory cell has an address that can be used to access that
location so a pointer variable points to a memory location we can access and change the
contents of this memory location via the pointer.
--------------------------------------------------------------------------------

Pointer declaration:
A pointer is a variable that contains the memory location of another variable in shich data is
stored. Using pointer,you start by specifying the type of data stored in the location. The
asterisk helps to tell the compiler that you are creating a pointer variable. Finally you have to
give the name of the variable. The syntax is as shown below.

type * variable name

--------------------------------------------------------------------------------

The following example illustrate the declataion of pointer variable

int *ptr;
float *string;

--------------------------------------------------------------------------------

Address operator:
Once we declare a pointer variable then we must point it to something we can do this by
assigning to the pointer the address of the variable you want to point as in the following
example:

ptr=&num;

The above code tells that the address where num is stores into the variable ptr. The variable ptr
has the value 21260,if num is stored in memory 21260 address then

--------------------------------------------------------------------------------

The following program illustrate the pointer declaration

/* A program to illustrate pointer declaration*/

main()
{
int *ptr;
int sum;
sum=45;
ptr=&sum
printf ("\n Sum is %d\n", sum);
printf ("\n The sum pointer is %d", ptr);
}

--------------------------------------------------------------------------------

Pointer expressions & pointer arithmetic:

In expressions,like other variables pointer variables can be used. For example if p1 and p2 are
properly initialized and declared pointers, then the following statements are valid.
y=*p1**p2;
sum=sum+*p1;
z= 5* - *p2/p1;
*p2= *p2 + 10;

C allows us to subtract integers to or add integers from pointers as well as to subtract one
pointer from the other. We can also use short hand operators with pointers p1+=; sum+=*p2;
etc., By using relational operators,we can also compare pointers like the expressions such as p1
>p2 , p1==p2 and p1!=p2 are allowed.

--------------------------------------------------------------------------------

The following program illustrate the pointer expression and pointer arithmetic
/*Program to illustrate the pointer expression and pointer arithmetic*/
#include< stdio.h >
main()
{ int ptr1,ptr2;
int a,b,x,y,z;
a=30;b=6;
ptr1=&a;
ptr2=&b;
x=*ptr1+ *ptr2 6;
y=6*- *ptr1/ *ptr2 +30;
printf("\nAddress of a +%u",ptr1);
printf("\nAddress of b %u",ptr2);
printf("\na=%d, b=%d",a,b);
printf("\nx=%d,y=%d",x,y);
ptr1=ptr1 + 70;
ptr2= ptr2;
printf("\na=%d, b=%d,"a,b);
}

Pointers and function:

In a function declaration,the pointer are very much used . Sometimes,only with a pointer a
complex function can be easily represented and success. In a function definition,the usage of
the pointers may be classified into two groups.
Call by reference
Call by value.

Call by value:
We have seen that there will be a link established between the formal and actual parameters
when a function is invoked. As soon as temporary storage is created where the value of actual
parameters is stored. The formal parameters picks up its value from storage area the
mechanism of data transfer between formal and actual parameters allows the actual parameters
mechanism of data transfer is referred as call by value. The corresponding formal parameter
always represents a local variable in the called function. The current value of the corresponding
actual parameter becomes the initial value of formal parameter. In the body of the actual
parameter,the value of formal parameter may be changed. In the body of the subprogram,the
value of formal parameter may be changed by assignment or input statements. This will not
change the value of the actual parameters.

/* Include< stdio.h >

void main()
{
int x,y;
x=20;
y=30;
printf("\n Value of a and b before function call =%d %d",a,b);
fncn(x,y);
printf("\n Value of a and b after function call =%d %d",a,b);
}

fncn(p,q)
int p,q;
{
p=p+p;
q=q+q;
}

Call by Reference:
The address should be pointers,when we pass address to a function the parameters receiving .
By using pointers,the process of calling a function to pass the address of the variable is known
as call by reference. The function which is called by reference can change the value of the
variable used in the call.
/* example of call by reference*?

/* Include< stdio.h >

void main()
{
int x,y;
x=20;
y=30;
printf("\n Value of a and b before function call =%d %d",a,b);
fncn(&x,&y); printf("\n Value of a and b after function call =%d %d",a,b);
}
fncn(p,q)
int p,q;
{
*p=*p+*p;
*q=*q+*q;
}
Pointer to arrays:
an array is actually very much similar like pointer. We can declare as int *a is an
address,because a[0] the arrays first element as a[0] and *a is also an address the form of
declaration is also equivalent. The difference is pointer can appear on the left of the assignment
operator and it is a is a variable that is lvalue. The array name cannot appear as the left side of
assignment operator and is constant.

/* A program to display the contents of array using pointer*/

main()
{
int a[100];
int i,j,n;
printf("\nEnter the elements of the array\n");
scanf(%d,&n);
printf("Enter the array elements");
for(I=0;I< n;I++)
scanf(%d,&a[I]);
printf("Array element are");
for(ptr=a,ptr< (a+n);ptr++)
printf("Value of a[%d]=%d stored at address %u",j+=,*ptr,ptr);
}
Pointers and structures
We know the name of an array stands for address of its zeroth element the same concept
applies for names of arrays of structures. Suppose item is an array variable of the struct type.
Consider the following declaration:

struct products
{
char name[30];
int manufac;
float net;
item[2],*ptr;

this statement ptr as a pointer data objects of type struct products and declares item as array of
two elements, each type struct products.

Pointers on pointer
A pointer contains garbage value until it is initialized. Since compilers cannot detect the errors
may not be known until we execute the program remember that even if we are able to locate a
wrong result,uninitialized or wrongly initialized pointers it may not provide any evidence for
us to suspect problems in pointers. For example the expressions such as

*ptr++, *p[],(ptr).member

What is an Array?
Arrays are collection of similar items (i.e. ints, floats, chars) whose memory is allocated in a
contiguous block of memory.
Pointers and arrays have a special relationship. To reference memory locations,arrays use
pointers. Therefore, most of the times, array and pointer references can be used
interchangeably.

Declaration of arrays
Arrays must be declared before they are used like any other variable. The general form of
declaration is:

type variable-name[SIZE];

The type specify the type of the elements that will be contained in the array, such as int,float or
char and the size indicate the maximum number of elements that can be stored inside the array.

The following example illustrate the use of array:

float height[50];

Declares the height to be an array containing the 50 real elements. Any subscripts 0 to 49 are
all valid. In C the array elements index or subscript begins with the number zero. So height [0]
refers to first element of the array. (For this reason, it is easier to think of it as referring to
element number zero, rather than as referring to first element). The declaration int values[10];
would reserve the enough space for an array called values that could hold up to 10 integers.
Refer to below given picture to conceptualize the reserved storage space.
 values[0]
values[1]
values[2]
values[3]
values[4]
values[5]
values[6]
values[7]
values[8]
values[9]

Initialization of arrays:
We can initialize the elements in an array in the same way as the ordinary variables when they
are declared. The general form of initialization off arrays is:

type array_name[size]={list of values};

The values in the list care separated by commas, for example the statement
int number[3]={0,0,0};

The initialization of arrays in c suffers two drawbacks

There is no convenient way to initialize only selected element.

There is no shortcut method to initialize large number of element

The following program to count the no of positive and negative numbers

/* Program to count the no of positive and negative numbers*/
#include< stdio.h >
void main( )
{
int a[50],n,count_neg=0,count_pos=0,I;
printf("Enter the size of the array\n");
scanf(%d,&n);
printf("Enter the elements of the array\n");
for I=0;I < n;I++)
scanf(%d,&a[I]);
for(I=0;I < n;I++)
{
if(a[I]< 0)
count_neg++;
else
count_pos++;
} printf("There are %d negative numbers in the array\n",count_neg);
printf("There are %d positive numbers in the array\n",count_pos);
}
Multi dimensional Arrays:
Often there is a need to store and manipulate two dimensional data structure such as the
matrices & tables. Here array has two subscripts. One subscript denotes row & the other the
column. The declaration of two dimension arrays is as follows:

data_type array_name[row_size][column_size];
int m[10][20];

The following program illustrate addition two matrices & store the results in the 3rd
matrix

/* example program to add two matrices & store the results in the 3rd matrix */
#include< stdio.h >
#include< conio.h >
void main()
{
int a[10][10],b[10][10],c[10][10],i,j,m,n,p,q;
clrscr();
printf("enter the order of the matrix\n");
scanf("%d%d",&p,&q);
if(m==p && n==q)
{
printf("matrix can be added\n");
printf("enter the elements of the matrix a");
for(i=0;i < m;i++)
for(j=0;j <n;j++)
scanf(%d,&a[i][j]);
printf("enter the elements of the matrix b");
for(i=0;i < p;i++)
for(j=0;j <q;j++)
scanf(%d,&b[i][j]);
printf("the sum of the matrix a and b is");
for(i=0;i <m;i++)
for(j=0;j <n;j++)
c[i][j]=a[i][j]+b[i][j];
for(i=0;i < m;i++)
{ for(j=0;j <n;j++)
printf(%d\t,&a[i][j]);
printf(\n);
}
}

What is Dynamic Memory Allocation?

Dynamic Memory Allocation is defined as the dynamically allocation of space for variables at
runtime.
It is wasteful when dealing with array type structures to allocate so much space when it is
declared
Five ANSI Standartd Function Used in Dynamic Memory Allocation
ANSI C provides five standard functions that will help you allocate memory on the heap which
are as follows:

1. sizeof()
2. malloc()
3. calloc()
4. realloc()
5. free()

The following table describe the five different standard functions that helps you allocate
memory dynamically
Function Task
Function Task
sizeof The sizeof() function returns the memory size of the requested variable

malloc Allocates memory requests size of bytes and returns a pointer to the Ist byte of allocated space

calloc Allocates space for an array of elements initializes them to zero and returns a pointer to the memory

free Frees previously allocated space

realloc Modifies the size of previously allocated space.

sizeof()
The sizeof() function returns the memory size of requested variable. This call should be used in
the conjunction with the calloc() function call, so that only the necessary memory is allocated,
rather than a fixed size. Consider the following,

struct date {
int hour, minute, second;
};

int x;

x = sizeof( struct date );

malloc()
A block mf memory may be allocated using the function called malloc. The malloc function
reserves a block of memory of specified size and return a pointer of type void. This means that
we can assign it to any type of the pointer. It takes the following form:

ptr=(cast-type*)malloc(byte-size);

ptr is a pointer of type cast-type the malloc returns a pointer (of cast type) to an area of
memory with the size byte-size. The following is the example of using malloc function
x=(int*)malloc(100*sizeof(int));

calloc()
Calloc is another memory allocation function that is normally used to request the multiple
blocks of storage each of same size and then sets all bytes to zero. The general form of calloc
is:

ptr=(cast-type*) calloc(n,elem-size);

The above statement allocates contiguous space for n blocks each size of the elements size
bytes. All bytes are initialized to zero and a pointer to the first byte of allocated region is
returned. If there is not enough space a null pointer is also returned.
realloc()
The memory allocated by using calloc or malloc might be insufficient or excess sometimes in
both the situations we can change the memory size already allocated with the help of the
function called realloc. This process is called the reallocation of memory. The general
statement of reallocation of memory is :

ptr=realloc(ptr,newsize);

free()
Compile time storage of a variable is allocated and released by the system in accordance with
its storage class. With the dynamic runtime allocation, it is our responsibility to release the
space when it is not required at all.When the storage is limited,the release of storage space
becomes important . When we no longer need the data we stored in a block of memory and we
do not intend to use that block for the storing any other information, Using the free function,we
may release that block of memory for future use.

free(ptr);

ptr is a pointer that has been created by using calloc or malloc.

The following program illustrate the reallocation of memory using realloc() and malloc()
/*Example program for reallocation*/

#include< stdio.h >

#include< stdlib.h >
define NULL 0
main()
{
char *buffer;
/*Allocating memory*/
if((buffer=(char *) malloc(10))==NULL)
{
printf("Malloc failed\n");
exit(1);
}
printf("Buffer of size %d created \n",_msize(buffer));
strcpy(buffer,Bangalore);
printf(\nBuffer contains:%s\n,buffer);
/*Reallocation*/
if((buffer=(char *)realloc(buffer,15))==NULL)
{
printf("Reallocation failed\n");
exit(1);
}
printf("\nBuffer size modified".\n);
printf("\nBuffer still contains: %s\n",buffer);
strcpy(buffer,Mysore);
printf("\nBuffer now contains:%s\n",buffer);
/*freeing memory*/
free(buffer);
}

What is a String?

1. A string is combination of characters.

2. Any set or sequence of characters defined within double quotation symbols is a
constant string.
3. In c it is required to do some meaningful operations on the strings
Initializing Strings
The initialization of a string must the following form which is simpler to the one dimension
array

char month1[ ]={‘j’,’a’,’n’,’u’,’a’,’r’,’y’};

The following example shows the use of string:

/*String.c string variable*/
#include < stdio.h >
main()
{
char month[15];
printf ("Enter the string");
gets (month);
printf ("The string entered is %s", month);
}

Note:
Character string always terminated by a null character ‘\0’. A string variable is always declared
as an array & is any valid C variable name. The general form of declaration of a string variable
is

Reading Strings from the terminal:

The function scanf with %s format specification is needed to read the character string from the
terminal itself. The following example shows how to read strings from the terminals:

char address[15];
scanf(%s,address);

String operations (string.h)

language recognizes that strings are terminated by null character and is a different class of
array by letting us input and output the array as a unit. To array out many of the string
manipulations,C library supports a large number of string handling functions that can be used
such as:
1. Length (number of characters in the string).
2. Concatentation (adding two are more strings)
3. Comparing two strings.
4. Substring (Extract substring from a given string)
5. Copy(copies one string over another)

strlen() function:
This function counts and returns the number of characters in a particular string. The length
always does not include a null character. The syntax of strlen() is as follows:

n=strlen(string);

Where n is the integer variable which receives the value of length of the string.

The following program shows to find the length of the string using strlen() function
/*writr a c program to find the length of the string using strlen() function*/
#include < stdio.h >
include < string.h >
void main()
{
char name[100];
int length;
printf("Enter the string");
gets(name);
length=strlen(name);
printf("\nNumber of characters in the string is=%d",length);
}

strcat() function:
when you combine two strings, you add the characters of one string to the end of the other
string. This process is called as concatenation. The strcat() function is used to joins 2 strings
together. It takes the following form:

strcat(string1,string2)

string1 & string2 are the character arrays. When the function strcat is executed string2 is
appended to the string1. the string at string2 always remains unchanged.

strcmp function:
In c,you cannot directly compare the value of 2 strings in a condition like if(string1==string2)
Most libraries however contain the function called strcmp(),which returns a zero if 2 strings are
equal, or a non zero number if the strings are not the same. The syntax of strcmp() is given
below:

Strcmp(string1,string2)

strcmpi() function
This function is same as strcmp() which compares 2 strings but not case sensitive.

Strcmp(string1,string2)

strcpy() function:
To assign the characters to a string,C does not allow you directly as in the statement
name=Robert; Instead use the strcpy() function found in most compilers the syntax of the
function is illustrated below.

strcpy(string1,string2);

strlwr () function:
This function converts all characters in a string from uppercase to lowercase

The syntax of the function strlwr is illustrated below

strlwr(string);

strrev() function:
This function reverses the characters in a particular string. The syntax of the function strrev is
illustrated below

strrev(string);

The following program illustrate the use of string functions:

/* Example program to use string functions*/
#include < stdio.h >
#include < string.h >
void main()
{
char s1[20],s2[20],s3[20];
int x,l1,l2,l3;
printf("Enter the strings");
scanf("%s%s",s1,s2);
x=strcmp(s1,s2);
if(x!=0)
{printf("\nStrings are not equal\n");
strcat(s1,s2);
}
else
printf("\nStrings are equal");
strcpy(s3,s1);
l1=strlen(s1);
l2=strlen(s2);
l3=strlen(s3);
printf("\ns1=%s\t length=%d characters\n",s1,l1);
printf("\ns2=%s\t length=%d characters\n",s2,l2);
printf("\ns3=%s\t length=%d characters\n",s3,l3);
}

What is a Structure?
1. Structure is a method of packing the data of different types.
2. When we require using a collection of different data items of different data types in that
situation we can use a structure.
3. A structure is used as a method of handling a group of related data items of different
data types.
Syntax of Using Structure
structure definition:
general format:
struct tag_name
{
data type member1;
data type member2;
....
...
}

Example of Using Structure:

struct lib_books
{
char title[20];
char author[15];
int pages;
float price;
};

To holds the details of four fields namely title, author pages and price,the keyword struct
declares a structure. These are the members of the structures. Each member may belong to
same or different data type. The tag name can be used to define the objects that have the tag
names structure. The structure we just declared is not a variable by itself but a template for the
structure. We can declare the structure variables using the tag name any where in the program.
For example the statement, struct lib_books book1,book2,book3; declares the
book1,book2,book3 as variables of type struct lib_books each declaration has four elements of
the structure lib_books. The complete structure declaration might look like this

The complete structure declaration might look like this

struct lib_books
{
char title[20];
char author[15];
int pages;
float price;
};

struct lib_books, book1, book2, book3;

Get the Length of a Node List

The node list is always keeps itself up-to-date. If an element is deleted or added, in the node
list or the XML document, the list is automatically updated.

The node list has a useful property called the length. The length property return the number of
node in a node list.

The following code fragment get the number of <title> elements in "bookdetails.xml":
struct lib_books { char title[20]; char author[15]; int pages; float price; }; struct lib_books,
book1, book2, book3;

The following program shows the use of structure

/* Example program for using a structure*/
#include< stdio.h >
void main()
{
int id_no;
char name[20];
char address[20];
char combination[3];
int age;
}newstudent;
printf("Enter the student information");
printf("Now Enter the student id_no");
scanf(“%d”,&newstudent.id_no);
printf(“Enter the name of the student”);
scanf(“%s”,&new student.name);
printf(“Enter the address of the student”);
scanf(“%s”,&new student.address);

printf(“Enter the cmbination of the student”);

scanf(“%d”,&new student.combination);

printf(Enter the age of the student”);

scanf(“%d”,&new student.age);
printf(“Student information\n”);
printf(“student id_number=%d\n”,newstudent.id_no);
printf(“student name=%s\n”,newstudent.name);
printf(“student Address=%s\n”,newstudent.address);
printf(“students combination=%s\n”,newstudent.combination);
printf(“Age of student=%d\n”,newstudent.age);
}

Union:
However the members that we compose a union all share the same storage area within the
computers memory where as each member within a structure is assigned its own unique
storage area. Thus unions are used to observe memory. They are useful for the application
involving multiple members. Where values need not be assigned to all the members at any
time. Unions like structure contain members whose individual data types may differ from one
another also. Like structures union can be declared using the keyword union as follows:

Last example will create a rectangle with rounded corner:

union item
{
int m;
float p;
char c;
}
code;

The notation for accessing a union member that is nested inside a structure remains the same
as for the nested structure.In effect,a union creates a storage location that can be used by one of
its members at a time. When a different number is assigned to a new value the new value
supercedes the previous members value. Unions may be used in all the places where a structure
is allowed.