CProgrammingTutorial

C Programming

A computer needs to be programmed to solve a problem.

C is a programming language developed at AT&T bell labs.

Any programming Language can be divided in to two categories.

Problem oriented (High level language)

Machine oriented (low level language)

C is considered as a middle level Language.

C is modular,portable,reusable

C is a language of few words that are known as keyword.

C code can be written in routines called function

Algorithm: to understand about the program

C is famous because reliable,simple,easy

Compactness,generality,efficiency,modularity and simplicity

Preparing to program

(1)Determine the objective of the program.

Determine the methods you want to use .

Create the program to solve the problem

Run the program for output

Feature of C Program

Structured language

General purpose language

Portability

Code Re usability

Ability to customize and extend

Limited Number of Key Word

Structured Language

It has the ability to divide and hide all the information and instruction.

Code can be partitioned in C using functions or code block.

C is a well structured language compare to other.

Portability

Portability is the ability to port or use the software written .

One computer C program can be reused.

By modification or no modification.

General Purpose Language

Make it ideal language for system programming.

It can also be used for business and scientific application.

ANSI established a standard for c in 1983.

The ability of c is to manipulate bits,byte and addresses.

It is adopted in later 1990.

Code Re usability and Ability to Customize and Extend

A programmer can easily create his own function

It can can be used repeatedly in different application

C program basically collection of function

The function are supported by 'c' library

Function can be added to 'c' library continuously

Limited number of keywords and unix library function

There are only 32 keywords in 'C'

27 keywords are given by ritchie

5 is added by ANSI

the strength of 'C' is lies in its in-built function

unix system provides as large number of C function

some function are used in operation .

other are for specialized in their application

'C' program structure

Pre-processor directives

Global declarations

Main( )

{

Local variable deceleration

Statement sequences

Function invoking

}

Writing,compiling and executing

Program need to be compiled before execution

'C' is case sensitive

Linking is the process of joining other program files

All keywords are lowercased

C is case sensitive

Keywords cannot be used for any other purpose

C statement always ends with a semicolon

No blank spaces are allowed with in a variable,constant or keyword

File should be have the extension .c

Recap of previous session

Introduction to programming

Features of 'C'

Writing,Compiling,Linking and executing

Writing a 'C' program

Introduction

Data types are used to declare a variety of different values.

Variables are important tool of a programmer

They are used to keep account of various values .

Like in a game ,weight or height of the player etc

Data types

Variable is an identifier

Variable must be declared before it is used in the program

'C' has 5 basic built-in data types

'C' supports aggregates data types

Data type defines a set of values that a variable can store along with a set of operations that can be performed on it.

A variable takes different values at different times

Modifiers are used to alter the meaning of the base type to fit the needs of various situations more precisely .

'C' has five basic built in data type

Char (character value)

Int (integer value)

Float (Floating point value)

Double (Double floating point value)

Void (Valueless)

Void is used to

Declare explicitly that a function is not returning a value

Declare explicitly that a function has no parameter

Create generic pointer

'C' also supports several aggregate types including structure ,union ,enumeration and user defined types.

Declaring a variable

A variable should be declare before it is used in the program

Example: data-type var-list;

Data type must be valid data type and var-list may be consist of one or more identifier names separated by commas operator.

The declaration indicates the compiler about the variable names and types of data

Example : int count;

double balance;

float amount;

Int, double,and float are keywords and cannot be used as variable names.

Assigning values

Values can be assigned to variable using the assignment operator (=).

var-name=expression;

An expression can be a single constant or combination of variables,operators and constants.

Data-type var-name=constant;

int value=250;

char name= “salini”

double amount =76.80

Type Modifier

The basic data types may have various modifiers preceding them except type void.

A modifier is used to alter the meaning of the base type to fit the needs of various situations more precisely.

The list of modifier:

Signed

Unsigned

Long

Short

Character

This is a group of 8 data bits.

'C' represents either a letter of roman alphabet.

Small integer in the range of 0 through to +255.

To give a named memory area in which a single letter has to be stored

Declaration

char letter;

Integer

There are two types of integers

Short

Long

The actual number of bits used in these types is implementation dependent.

For sixteen bit machine ,the long integer is two machine words long,and short integer is one machine word long.

short int smaller_number;

long int big_number;

Real number

Float offers two sizes-float and double that are similar to integer type

Approximately float represents six significant digit and double is twelve.

float length_of_water_line;

double displacement;

Signed and unsigned prefixes

The deceleration can be preceded by the word unsigned for both the character and integer types which the range so that 0 is the minimum,and the maximum is twice that of the signed data type.

If the word in memory is going to be used as a bit pattern or a mask and not a number, the use of unsigned is strongly urged.

The default for the int types is always signed , and char is machine dependent.

Character Set

Characters are used to form the words, numbers and expression

The characters in 'C' are grouped into the following categories:

character set- alphabets from A....Z,a....z

All decimal digits from 0.....9

Special characters include

, . ; : ? ' " ! / | ~ - $

% # & ^ * _ + < > ( ) { } [ ] blank space

Keywords and Indentifier

Every ' C' word is classified as either a keyword or an identifier.

All identifier have fixed meaning, which can not be changed.

Rules for identifier

Legal characters are a-z, A-Z,0-9 and _

Case significant

The first character must be a letter or _

Identifier can be of any length

The reserved keywords should not be used as identifier.

Valid identifier invalid identifier

Count . 1count

Test23 .hi!

high_bal . high balance

keywords

Auto double int struct break

Long switch case enum register

Typedef char extern return union

Float unsigned short continue for

Signed void default goto sizeof

Volatile do if static while

Else const

Constants

Supports numerical as well as character constants.

'C' supports several types of constants.

'C' has two types of modifier.

Variable of type const cannot be modified

Constants are fixed values that do not change during the execution of a program.

'C' supports both numeric and character constants

C supports several types constant

Numeric constant

Integer constant

Floating point (real) constant

Character constant

Single character constant

String constant

The following rules apply to all numeric constant

Non- digit characters and blanks cannot be included

Can be preceded by minus sign

Escape sequences

Certain non printing characters as well as the backslash () and the apostrophe('), can be expressed in terms of escape sequence.

Example for new line

Bell a carriage return

Backspace formfeed f

Horizontal tab quotation mark ”

Vertical tab v apostrophe '

Backslash \ question mark ?

Null

Access modifier

C has two type modifiers that can be used to control the way in which variables may be accessed or modified.

These are

Const

example const int my_age=39;

Volatile

example volatile int date

Operator

Three kinds of operators.

Two types of casting.

'C' includes a class of operators .

That act upon a single operand to produce a new value.

Ternary operator operates on three operands.

'C' is very rich in built -in operator.

An operator is a symbol that indicates the compiler to perform specific mathematical or logical manipulation.

Three general classes of operator

Arithmetic operator

Relational operator

Assignment operator

Special operators to perform particular task

Ternary (conditional) operator

Size of operator

Comma operator

& Operator

. and -> operator

Arithmetic Operators

Operator Action Example

_ Subtraction a-b

+ Addition a+b

* Multiplication a*b

/ division a/b

% modulus Division a%b

- Decrement a- or -a

++ increment a+ or ++

casting

When operand differ in type they may undergo type conversion before the expression takes on its final value.

The final result will be expressed in the highest precision possible, consistent with data type of the operand.

There are two types of casting

Implicit

Explicit

Implicit casting

If either operand is long double, convert the other to long double

If either operand is double , convert the other to float.

Convert char and short to int.

If either operand is long convert the other to long.

Explicit casting

The expression can be converted to a different data type if desired data type, enclosed in parentheses

(data type) expression

int a+m;

sqrt ((double)x)

The cast produces the value of the proper type;x itself is not altered

Linking with math library

This is following code links to the math library

cc -o cast cast.c – lm

the -l switch stands for 'library'

The library that is searched in the case is libm.a the path u search that is '/usr/lib' where libm.a is found .

Unary operator

'C' include a class of operators that act upon a single operand to produce a new value.

The most common unary operation is unary minus.

Example

-143 -(a+m)

-12 -3.2

Increment and Decrement

x=x+1;

x+=1;

x++;

x=x-1;

x-=1;

Postfix and Prefix

A postfix expression is obtained by post fixing a++ or – operator

The value of the expression is the value of the operand.

x=10;

y=++x;

x=10;

y=x++;

Relational and Logical operator

Operator Meaning

< is less then

<= is less then or equal to

> is greater then

>= is greater then or equal to

== is equal to

!= is not equal

&& Logical AND

|| Logical OR

! Logical NOT

Conditional (:?) Operator

var=exp1?exp2:exp3

x=10;

y=x>9 ?100:200;

x=10;

if (x>9)

{

y=100;

}

else

{

y=200;

}

Recap of previous session

Data type

Constants

Operator

POINTERS

Simply stated, a pointer is an address. Instead of being a variable, it is a pointer to a variable stored

somewhere in the address space of the program. It is always best to use an example so load the file named POINTER.C and display it on your monitor for an example of a program with some pointers in it.

For the moment, ignore the data definition statement where we define index and two other fields

POINTERS CONT..

beginning with a star. It is properly called an asterisk, but for reasons we will see later, let's agree to call

it a star. If you observe the statement in line 8, it should be clear that we assign the value of 39 to the

variable named index. This is no surprise, we have been doing it for several programs now. The

statement in line 9 however, says to assign to pt1 a strange looking value, namely the variable index with

POINTERS CONT....

An ampersand in front of it. In this example, pt1 and pt2 are pointers, and the variable named index is a simple variable. Now we have a problem similar to the old chicken and egg problem. We need to learn

how to use pointers in a program, but to do so requires that first we define the means of using the pointers in the program.

The following two rules will be somewhat confusing to you at first, but we need to state the definitions

before we can use them. Take your time, and the whole thing will clear up very quickly.

POINTERS

TWO VERY IMPORTANT RULES

The following two rules are very important when using pointers and must be thoroughly understood.

1. A variable name with an ampersand in front of it defines the address of the variable and therefore points to the variable. .

2. A pointer with a star in front of it refers to the value of the variable pointed to by the pointer line.

POINTERS

Twelve of the program can be read as "The stored (starred) value to which the pointer pt1 points is

assigned the value 13". This is commonly referred to as dereferencing the pointer. Now you can see why it is convenient to think of the asterisk as a star, it sort of sounds like the word store.

MEMORY AIDS

1. Think of & as an address.

2. Think of * as a star referring to stored.

NULL POINTERS

#include <stdio.h>

int *ip = NULL;

if(ip != NULL)

printf("%d ", *ip);

NULL POINTERS

#include <stddef.h>

char *mystrstr(char input[], char pat[]) {

char *start, *p1, *p2;

for(start = &input[0]; *start != ''; start++)

{ /* for each position in input string... */

p1 = pat; /* prepare to check for pattern string there */

p2 = start;

while(*p1 != ''){

if(*p1 != *p2) /* characters differ */

break;

p1++;

p2++;

}

if(*p1 == '') /* found match */

return start;

}

return NULL;

}

Equivalence in Array and pointer

There are a number of similarities between arrays and pointers in C. If you have an array

int a[10];

you can refer to a[0], a[1], a[2], etc., or to a[i] where i is an int. If you declare a pointer variable ip and set it to point to the beginning of an array:

int *ip = &a[0];

Arrays and Pointers as Function Arguments

int getline(char *line, int max){

int nch = 0;

int c;

max = max - 1; /* leave room for '' */

#ifndef FGETLINE

while((c = getchar()) != EOF)

#else

while((c = getc(fp)) != EOF)

#endif{

if(c == ' ')

break;

if(nch < max){

line[nch] = c;

nch = nch + 1;

}

}

if(c == EOF && nch == 0)

return EOF;

line[nch] = '';

return nch;

}

String

char internal_string_1[] = "Hello";

char internal_string_2[] = "world";

char *p1 = &internal_string_1[0];

int len = strlen(&internal_string_2[0]);

Preprocessor Directives

Preprocessor directives are instructions to the compiler that begin with a # sign.

Executed before the compilation begin.

Most frequently used directives

- #include

- #define

Notes

It instruct s the compiler to include a header file,specified within angled brackets or double quote,after the #include statement into the source code

A header or a standard library contain a set of related functions,which perform various tasks in a program.

Header file generally have extension '.h'.

stdio.h contains a set of console i/o functions

#include referred to as nested includes.

The number of nesting varies from compiler to compiler.

Header files are usually placed in a special library called include .

If the name of the header file is specified in angled brackets,the file searched for in this directory the file name is enclosed in double quotes,the file is looked for in an implementation-defined manner.

Macros

Macro is imperative that there is no space between the macro name and the opening parenthesis.

#include “stdio.h” #define START 0 /*starting point of loop*/

#define ENDING 9 /*Ending point of loop*/

#define MAX (A,B) ((A)>(B)?(B):(A)) /*Max macro definition*/

#define MIN (A,B) ((A)>(B)?(B):(A)) /*Min macro definition*/

main ( )

{

int index, mn,mx;

int count = 5

.

mx=max (index,count);

mn=min(index,count);

.

.

}

Getchar( )

The simplest i/o function to read the input and show the standard output .

The getchar( ) function reads a single character from the console.

The function does not require any arguments,through a pair of parentheses must follow the word getchar.

Example

<var_name>=getchar( );

char name;

name =getchar( );

Putchar( )

Single character can be written to the terminal using the 'C' library function putchar( ) Example

putchar (var_name)

name ='A'

putchar(name)

The above putchar ( ) will display the character A on the screen

Printf( )

The printf( )function provides certain features that can be effectively exploited to control the alignment and spacing of prints outs on the terminal.

printf(“format-string”,arg1,arg2,arg3,......);

The format -strings defines the way in which the subsequent argument arg1,arg2...are to be displayed.

The format string consist of two types

-Character that will be printed on the terminal.

-format commands that defines the output format of each argument

Printf(“hello %c %d %s”, 'x', '12', “there!”);

will display

hello x 12 there!

Scanf( )

Scanf is used for reading in data from the standard input (keyboard).

Scanf (“format-string” &arg1,&arg2...);

The format string may include:

Field specifier

Optional field width

Optional white and non-whit character.

Example:

scanf (“%d”, &count);

List all format

Code Format

%c Character

%d Signed decimal integer

%i Signed decimal integer

%e Scientific notation[e]

%E Scientific notation[E]

%f Decimal floating point

%o unsigned octal

%s String of character

%u unsigned decimal integer

%x unsigned Hexadecimal (lower)

%X unsigned Hexadecimal (upper)

%p dispaly a pointer

%% print a %

Mixed data Output

It is permitted to mix data types in one printf statement.

Example

Printf (“%d%f%s%c, a,b,c,d);

this is big advantage in the 'C' .

Types

The type of a variable determines what kinds of values it may take on. An operator computes new values out of old ones. An expression consists of variables, constants, and operators combined to perform some useful computation. In this chapter, we'll learn about C's basic types, how to write constants and declare variables of these types, and what the basic operators are.

As Kernighan and Ritchie say, ``The type of an object determines the set of values it can have and what operations can be performed on it.'' This is a fairly formal, mathematical definition of what a type is, but it is traditional (and meaningful). There are several implications to remember.

Types

1. The ``set of values'' is finite. C's int type can not represent all of the integers; its float type can not represent all floating-point numbers.

2. When you're using an object (that is, a variable) of some type, you may have to remember what values it can take on and what operations you can perform on it. For example, there are several operators which play with the binary (bit-level) representation of integers, but these operators are not meaningful for and may not be applied to floating-point operands.

3. When declaring a new variable and picking a type for it, you have to keep in mind the values and operations you'll be needing.

In other words, picking a type for a variable is not some abstract academic exercise; it's closely connected to the way(s) you'll be using that variable.

Types cont...

There are only a few basic data types in C. The first ones we'll be encountering and using are:

* char a character

* int an integer, in the range -32,767 to 32,767

* long int a larger integer (up to +-2,147,483,647)

* float a floating-point number

* double a floating-point number, with more precision and perhaps greater range than float

Constants A constant is just an immediate, absolute value found in an expression. The simplest constants are decimal integers, e.g. 0, 1, 2, 123 . Occasionally it is useful to specify constants in base 8 or base 16 (octal or hexadecimal); this is done by prefixing an extra 0 (zero) for octal, or 0x for hexadecimal: the constants 100, 0144, and 0x64 all represent the same number. (If you're not using these non-decimal constants, just remember not to use any leading zeroes. If you accidentally write 0123 intending to get one hundred and twenty three, you'll get 83 instead, which is 123 base 8.)

Declaration

. You may wonder why variables must be declared before use. There are two reasons:

1. It makes things somewhat easier on the compiler; it knows right away what kind of storage to allocate and what code to emit to store and manipulate each variable; it doesn't have to try to intuit the programmer's intentions.

2. It forces a bit of useful discipline on the programmer: you cannot introduce variables willy-nilly; you must think about them enough to pick appropriate types for them. (The compiler's error messages to you, telling you that you apparently forgot to declare a variable, are as often helpful as they are a nuisance: they're helpful when they tell you that you misspelled a variable, or forgot to think about exactly how you were going to use it.)

Function calls

printf("Hello, world! ")

printf("%d ", i)

sqrt(144.)

Getchar()

Expression statement

Most of the statements in a C program are expression statements. An expression statement is simply an expression followed by a semicolon. The lines

i = 0;

i = i + 1;

and

printf("Hello, world! ");

If statement

if( expression )

{

statement<sub>1</sub>

}

Boolean expression

< less than

<= less than or equal

> greater than

>= greater than or equal

== equal

!= not equal

While loop

int x = 2;

while(x < 1000)

{

printf("%d ", x);

x = x * 2;

}

For loop

for (i = 0; i < 10; i = i + 1)

printf("i is %d ", i);

Break and continue

#include <stdio.h>

#include <math.h>

Main() {

int i, j;

printf("%d ", 2);

for(i = 3; i <= 100; i = i + 1)

{

for(j = 2; j < i; j = j + 1)

{

if(i % j == 0)

break;

if(j > sqrt(i))

{

printf("%d ", i);

break;

}

}

}

return 0;

}

Character output

The library function putc ( ) writes a single character to a specified stream. Its prototype, in stdio.h

int putc (int ch,FILE *fp)

With other character function ,it is for mally called a type int,but only the lower-order byte is used.

To write a line of characters to a stream fputs( ) library function is used.

fputs( ) doesn't add a new line to the end of the string if you want u have to include it.

char fputs(char *str,FILE *fp);

File pointer and Fopen

ifp = fopen("input.dat", "r");

if(ifp == NULL)

{

printf("can't open file ");

exit or return

}

I/O with file pointer

#include <stdio.h>

/* Read one line from fp, */

/* copying it to line array (but no more than max chars). */

/* Does not place terminating in line array. */

/* Returns line length, or 0 for empty line, or EOF for end-of-file. */

int fgetline(FILE *fp, char line[], int max) {

int nch = 0;

int c;

max = max - 1; /* leave room for '' */

while((c = getc(fp)) != EOF) {

if(c == ' ')

break;

if(nch < max)

{

line[nch] = c;

nch = nch + 1;

}

}

if(c == EOF && nch == 0)

return EOF;

line[nch] = '';

return nch;

}

Predefined Stream

if((ifp = fopen(filename, "r")) == NULL)

{

fprintf(stderr, "can't open file %s ", filename);

exit or return

}

Closing files

Although you can open multiple files, there's a limit to how many you can have open at once. If your program will open many files in succession, you'll want to close each one as you're done with it; otherwise the standard I/O library could run out of the resources it uses to keep track of open files. Closing a file simply involves calling fclose with the file pointer as its argument:

fclose(fp);

Character Input/output

#include <stdio.h>

/* copy input to output */

Main() {

int c;

c = getchar();

while(c != EOF)

{

putchar(c);

c = getchar();

}

return 0;

}

UNIX File Redirection

UNIX has a facility called redirection which allows a program to access a single input file and a single output file very easily. The program is written to read from the keyboard and write to the terminal screen as normal.

To run prog1 but read data from file infile instead of the keyboard, you would type

prog1 < infile

To run prog1 and write data to outfile instead of the screen, you would type

prog1 > outfile

Both can also be combined as in

prog1 < infile > outfile

Redirection is simple, and allows a single program to read or write data to or from files or the screen and keyboard.

Some programs need to access several files for input or output, redirection cannot do this. In such cases you will have to use C's file handling facilities.

Memory Management Dynamic memory management

Agenda

Introduction / Overview

Memory Leak

Valgrind

Bounds Checker

Case study

Summary

Reference

Introduction / Overview

Memory Allocation At Run Time Is Referred As Dynamic Memory Allocation.

Dynamic Memory Management Plays Is An Explicit Action In Language Like C , C++.

Hard Track Problems

Freeing An Allocated Memory Twice.

Running Off The Edges Of The Alloc ‘d Buffer.

Failing To Keep Track Of Alloc ‘d Block.

Memory Leak

What is ?

Chunk of Memory Allocated and Never been Freed in the Course of Program.

Typically happens when you reset pointer to NULL or to a New Address without freeing it first.

How to Solve ?

Find out where exactly Memory Leak Occurred.

Memory Leak cont…

Why is it Bad?

Reduces the performance of the Application.

Memory Intensive and Long Run Application May Fail.

Leads to Application Crash.

Difficult to Detect.

Are there any Tools ?

Valgrind

Bounds Checker

Rational Purify Plus

Memprof

Developed by Julian Seward.

It is Non-Intrusive.

Finds Memory Leak in any Application without Recompilation.

Identifies

Un-initialized Data.

Reading/Writing Memory after it has been freed.

Reading/Writing Memory off the allocated Block.

Memory Leaks

Valgrind

Installation

Where do I get Installable ?

http://valgrind.kde.org/

How to Install ?

From Source Package (valgrind-2.0.0.tar.bz2)

$bunzip valgrind-2.0.0.tar.bz2

$cd valgrind-2.0.0

$./configure –prefix=“installation-directory”

$make

$make install

From Binary Package (valgrind-2.0.0-1.rh90.dag.i386)

#rpm –i –v valgrind-2.0.0-1.rh90.dag.i386

Valgrind cont…

Usage

Valgrind [val-opt] prog-to-check [prog-opt]

Example

Valgrind –skin=memcheck ls –l

`“skin” --- specifies one of the functionality valgrind supports

“ ls –l” --- specifies the program to be analyzed.

Valgrind writes a commentary,detailed error reports and other significant events in user friendly format.

Output Format

===process-id=== Message-from-valgrind

example

===12343=== Invalid Read

Valgrind cont…

Functionality Support

Valgrind generates reports based on the value specified in the “skin” option.

The supported skin/functionalities are

Memcheck

Addrcheck

Helgrind

Cachegrind

Valgrind cont…

Memcheck

Detects uninitialized data/memory block.

Detects Memory Leak.

Detects Invalid Memory Read/Write.

Slow compared to other functionality.

Addrcheck

Light Weight version of Memcheck.

Does not check for Uninitialised data/Memory.

Faster than Memcheck.

Valgrind cont…

Cachegrind

Profiles I1,D1 and L2 Caches.

Simulates I1,D1 and L2 Caches.

Helgrind

Idenitifies Memory Location Which are accessed without Synchronization.

Identifies Data Race in Multithreaded Programs.

Valgrind cont…

Memcheck

It supports 2 flags

--leak-check=[no/yes]

When disabled (no) , identifies the number of alloc ‘d and freed block.

When enabled (yes) , identifies the memory leaks.

--show-reachable=[no/yes]

When disabled (no) , reports block of memory for which pointer it is not available and not freed.

When enabled (yes) , reports block of memory for which pointer is available and and not freed.

Valgrind cont…

Uninitialised Memory (example1.c)

int main ()

{

char *cptr = NULL;

cptr = (char *) malloc (sizeof (char)) ;

if (cptr)

{

printf ("Value of cptr = [%c] " ,cptr [0]) ;

}

free (cptr) ;

cptr = NULL ;

return 0 ;

}

$gcc –o example1 –g example1.c

$valgrind –skin=memcheck –leak-check=yes ./example1

Case studies

Reading/Writing Freed Memory

int main ()

{

char *cptr = NULL;

cptr = (char *) calloc (1, sizeof (char) * 128) ;

if (cptr)

{

strcpy (cptr , "Example...2") ;

free (cptr) ;

printf ("The Program Name is [%s] " , cptr) ;

strcpy (cptr , "End of Example 2" ) ;

}

return 0 ;

}

Case studies

Reading/Writing off the allocated block

int main ()

{

char *cptr = NULL;

cptr = (char *) calloc (1, sizeof (char) * 10 ) ;

if (cptr)

{

strcpy (cptr , "Example3") ;

printf ("Character At position 10 is [%sc] " , cptr [10]) ;

cptr [10] = 'c' ;

}

free (cptr) ;

cptr = NULL ;

return 0 ;

Case studies

Memory Leak

int main ()

{

char *cptr = (char *) calloc (1, sizeof (char) * 25) ;

if (cptr)

{

strcpy (cptr , "Hello!") ;

}

function () ;

}

void function ()

{

char *ptr = NULL ;

ptr = (char *) calloc (1 , sizeof (char) * 128) ;

if (ptr){

strcpy (ptr , "Example 5") ;

}

}

Case studies

Illegal Memory Free

int main ()

{

char *cptr = (char *) calloc (1, sizeof (char) * 128) ;

if (cptr)

{

strcpy (cptr , "Testing...") ;

printf ("The string is [%s]" , cptr) ;

free (cptr) ;

}

free (cptr) ;

return 0 ;

}

Case studies

Advantages

Good memory checker and more, can also be used for profiling.

Really Fast for Memory Checker.

Code doesn’t be instrumented.

It is an open source and with excellent support

Disadvantages

Only available for Linux x86

Might sometimes give false positives if code is compiled with optimization.

Valgrind cont…

Available on Window9x/2000/NT Platform.

Can be Used With Windows ME , If Windows ME took kit is installed.

Bounds Checker can be used with VC++ Integrated Environment or as a Standalone Application or from Dos Command Line.

Bounds Checker

What it does?

Identifies Memory Overrun.

Memory Leak.

Dangling Pointer.

Windows Function Failure.

Invalid Argument to windows Function.

Stack Memory Overrun.

Array index out of bound.

Returning Pointer to Local Variable

Bounds Checker cont…

Using Microsoft Visual C++ IDE

On file menu , click open workspace to locate and open your program.

On bounds check menu , click integrated debugging to enable bounds checker.

On the build menu, point to start debug, and then click go.

Bounds Checker cont …

Using Bounds Check Standalone Application

Start Bounds Checker Standalone Application

On Bounds Checker File menu, click Open.

Select the file you want to load and click open

On the program menu , click Run.

Bounds Checker cont…

Case studies

main ()

{

char *name = NULL ;

int n = -1;

name = (char *) malloc (10) ;

printf ("String is [%s] " , name) ;

name [n] = 'U' ;

name [10] = 'O' ;

name = (char *) calloc (1 , sizeof (char) * 10) ;

free (name) ;

printf ("The character at position 10 is [%c] " , name [10]) ;

free (name) ;

return 0 ;

}

Array Index Outoff Range

In C language array index starts from ‘0’.

Since n = -1 , name[n] = ‘U’ is an invalid write.

Bounds checker identifies the above error as Index Out of Range.

Case studies

Memory Overrun

The memory block allocated for name is 10 bytes.

name [10] = ‘O’ is an invalid write.

Bounds checker identifies the above error has writing overflows memory.

Case studies

Memory Leak

The pointer “name” pointing to previously allocated memory is reassigned with new pointer before freeing the memory block to which it was pointing.

Pointer to previously allocated memory is lost.

Bounds Checker Identifies it as memory leak.

Case studies

Dangling Pointer

Trying to access memory which has been freed.

Bounds Checker Identifies it has Dangling Pointer.

Case studies

Dangling Pointer

Trying to free already freed memory.

Bounds Checker Identifies the above as Dangling Pointer.

Case studies cont…

Most of the hard to trace bugs occurs in dynamic memory management.

Invalid free,read/writes are the most common errors.

Care Should be taken to avoid Array Index Out of Range

Memory Leak should be avoided.

All Variables should be initialized.

Summary

Website

Valgrind

http://valgrind.kde.org/

-Bounds Checker

http://www.compuware.com/products/devpartner/bounds.htm

Reference

Linked list

This section teaches the concepts of linked list using an example. Consider an institute that maintains records of students.

Data processing frequently involves storing and processing data that is organized ito a list.

Linked list is a self-referential data structure and consecutive collection of related data structure.

Each element of the list can be made to have a field, called the link or pointer,which contains the address of the next element in the list.

In this case successive elements need not occupy adjacent space in memory which also makes it easier to insert and delete elements in the list.

Concept of linked list

Used to store a series of data of any type

Allows to manage the data effectively

Also known as one-way list

A linear collection of data elements called nodes

A self-referential data structure

Arrays

An array is a collection of contiguous storage locations. Each location holds one element. All elements must be of the same type. The elements are referenced by position using an integer variable or constant called the subscript or index. In C language, the first position is position 0.

Array cont.......

The array name represents the address of the beginning of the array. Since arrays are considered to be large structures, we do not want to waste time and space copying arrays when we pass them to subroutines. Therefore, an array is passed by reference, even if the data stored in the array won't be changed. In C-language arrays are automatically passed by reference.

Array cont.......

In general, there are two values a user needs to be able to process an array correctly, namely, the maximum size of the array and the current size of the array. Here is a typical C-language array declaration.

Array cont.......

#define MAX_SIZE 100

int x[MAX_SIZE]; /* an array of integer */

int curSize; /* how many elements are currently being used */

Since numbering the elements starts at 0, the elements of array x are x[0].. x[MAX_SIZE-1]. The companion variable curSize tells us that valid data is stored at x[0]..x[curSize-1] .

Other String Handling Functions

As well as sprintf and sscanf, the UNIX system has a number of other string handling functions within its libraries. A number of the most useful ones are contained in the <strings.h> file, and are made available by putting the line

#include <strings.h>

near to the head of your program file.

A couple of the functions are described below.

A full list of these functions can be seen using the man command by typing man 3 strings

When writing a large program, you may find it convenient to split it several source files. This has several advantages, but makes compilation more complicated.

This section will discuss advantages and disadvantages of using several files in a program, and advise you on how to divide a program between several files, should you wish to do so.

Programs with Several Files

Advantage of using several files The main advantages of spreading a program across several files are: Teams of programmers can work on programs. Each programmer works on a different file. An object oriented style can be used. Each file defines a particular type of object as a datatype and operations on that object as functions. The implementation of the object can be kept private from the rest of the program. This makes for well structured programs which are easy to maintain. Files can contain all functions from a related group. For Example all matrix operations. These can then be accessed like a function library. Well implemented objects or function definitions can be re-used in other programs, reducing development time. In very large programs each major function can occupy a file to itself. Any lower level functions used to implement them can be kept in the same file. Then programmers who call the major function need not be distracted by all the lower level work. When changes are made to a file, only that file need be re-compiled to rebuild the program. The UNIX make facility is very useful for rebuilding multi-file programs in this way.

How to Divide a Program between Several Files Where a function is spread over several files, each file will contain one or more functions. One file will include main while the others will contain functions which are called by others. These other files can be treated as a library of functions. Programmers usually start designing a program by dividing the problem into easily managed sections. Each of these sections might be implemented as one or more functions. All functions from each section will usually live in a single file. Where objects are implemented as data structures, it is usual to to keep all functions which access that object in the same file. The advantages of this are; The object can easily be re-used in other programs.

How to Divide a Program between Several Files All related functions are stored together. Later changes to the object require only one file to be modified. Where the file contains the definition of an object, or functions which return values, there is a further restriction on calling these functions from another file. Unless functions in another file are told about the object or function definitions, they will be unable to compile them correctly. The best solution to this problem is to write a header file for each of the C files. This will have the same name as the C file, but ending in .h. The header file contains definitions of all the functions used in the C file. Whenever a function in another file calls a function from our C file, it can define the function by making a #include of the appropriate .h file.

Organization of Data in File Any file must have its data organized in a certain order. This will typically be: A preamble consisting of #defined constants, #included header files and typedefs of important data types Declaration of global and external variables. Global variables may also be initialized here. One or more functions. The order of items is important, since every object must be defined before it can be used. Functions which return values must be defined before they are called. This definition might be one of the following:

Organization of Data in File Where the function is defined and called in the same file, a full declaration of the function can be placed ahead of any call to the function. If the function is called from a file where it is not defined, a prototype should appear before the call to the function. A function defined as float find_max(float a, float b, float c) { /* etc ... ... */ would have a prototype of float find_max(float a, float b, float c); The prototype may occur among the global variables at the start of the source file. Alternatively it may be declared in a header file which is read in using a #include. It is important to remember that all C objects should be declared before use.

This process is rather more involved than compiling a single file program. Imagine a program in three files prog.c, containing main(), func1.c and func2.c. The simplest method of compilation (to produce a runnable file called a.out)

cc prog.c func1.c func2.c

If we wanted to call the runnable file prog we would have to type

cc prog.c func1.c func2.c -o prog

In these examples, each of the .c files is compiled, and then they are automatically linked together using a program called the loader ld.

Compiling Multi-File Programs

We can also compile each C file separately using the cc -c option. This produces an object file with the same name, but ending in .o. After this, the object files are linked using the linker. This would require the four following commands for our current example.

cc -c prog.c

cc -c func1.c

cc -c func2.c

ld prog.o func1.o func2.o -o prog

Each file is compiled before the object files are linked to give a runnable file.

The advantage of separate compilation is that only files which have been edited since the last compilation need to be re-compiled when re-building the program. For very large programs this can save a lot of time.

The make utility is designed to automate this re-building process. It checks the times of modification of files, and selectively re-compiles as required. It is an excellent tool for maintaining multi-file programs. Its use is recommended when building multi-file programs

Separate Compilation

We have already used make to build single file programs. It was really designed to help build large multi-file programs. Its use will be described here.

Make knows about `dependencies' in program building. For example;

* We can get prog.o by running cc -c prog.c.

* This need only be done if prog.c changed more recently than prog.o.

make is usually used with a configuration file called Makefile which describes the structure of the program. This includes the name of the runnable file, and the object files to be linked to create it. Here is a sample Makefile for our current example

# Sample Makefile for prog

#

# prog is built from prog.c func1.c func2.c

Using make with Multi-File Programs

# Object files (Ending in .o,

# these are compiled from .c files by make)

OBJS = prog.o func1.o func2.o

# Prog is generated from the object files

prog: $(OBJS)

$(CC) $(CFLAGS) -o prog $(OBJS)

# ^^^ This space must be a TAB.

# Above line is an instruction to link object files

This looks cluttered, but ignore the comments (lines starting with #) andthere are just 3 lines.

When make is run, Makefile is searched for a list of dependencies. The compiler is involved to create .o files where needed. The link statement is then used to create the runnable file.

make re-builds the whole program with a minimum of re-compilation, and ensures that all parts of the program are up to date. It has many other features, some of which are very complicated.

For a full description of all of these features, look at the manual page for make by typing

Using make with Multi-File Programs CONT....

Reading lines

while((c = getchar()) != EOF && c != ' ')

{

if(nch < max)

{

line[nch] = c;

nch = nch + 1;

}

}

Reading number

#include <stdlib.h>

char line[256];

double x;

printf("Type a floating-point number: ");

getline(line, 256);

x = atof(line);

IntelliBitz Technologies Training Division 168, Medavakkam Main Road Madipakkam, Chennai 91. PH: +91 044 2247 5106 www.intellibitz.com [email_address]