Index

PROGRAMMING
IN ‘C’
• Index
○ Section one
 Introduction to c Programming
□ Where is c Useful
□ Why you should learn c?
 Features Of C
□ C language keywords
 Data Types
□ Primary Data Type
 Integer Type
 Floating Point Type
 Void Type
 Character Type
□ Derived Data Type (also known as Composite data type)
 Array
Pointer

Pgramming in C Page 1
  Pointer
 Structure
 Union
 Enum, etc.
□ User defined Data Type
 Variable
□ Variable Names
□ Local Variables
□ Global Variable
 Constants
□ Types of constants
 Character
 Integer
 Real
 String
 Logical
 C Language Operator Precedence Chart
 Operators
□ Arithmetic Operators
 Integer Arithmetic
 Floating point Arithmetic
 Mixed Mode Arithmetic
□ Relational Operators
□ Logical Operators
 Logical AND (&&)
 Logical OR (||)
 Logical NOT (!)
□ Assignment Operators
□ Increment And Decrement Operators
□ Conditional or Ternary Operators
□ Bitwise Operators
□ Special Operators
 Comma Operator
 The Size of Operator
 Pointer operator
 Member selection operator
 The Input And Output
□ The Standard Input output file
 Character input output
 Formatted input output
 Whole lines of input and output
 Expression Statements
○ Section Second
 Control Flow Statement
□ If - Statement
□ If - Else Statement
□ Nested-If - Statement
Pgramming in C Page 2
 □
□ Nested-If - Statement
□ Switch Case
 Loops
□ While Loop
□ For Loop
□ Do While Loop
 Break Statement
 Continue Statement
 Function
□ Recursive Function
 Array And String
□ Array
 One Dimensional Array
 Multidimensional Array
□ String
○ Section Third
 Structures
□ Introduction to structure
□ Define Structure?
□ Accessing Members Of a Structure
□ Array Of Structure
□ Structure Within a Structure
 Union
 Pointer
□ Pointer
 Pointer Declaration
 Address Operator
 The following program illustrate the pointer
declaration
 Pointer expressions & pointer arithmetic
 The following program illustrate the pointer expression
and pointer arithmetic
 Pointers and function
 Pointer to arrays
 Pointers and structures
 What is a file?
 ASCII Text Files
 Binary Files
 Bubble Sort
 Binary Search
 Keywords

Pgramming in C Page 3
Pgramming in C Page 4
Pgramming in C Page 5
 Introduction to C Programming
Friday, August 06, 2010
8:06 PM

Introduction to C Programming
C is a general-purpose computer programming language developed in 1972 by Dennis Ritchie at the Bell Telephone Laboratories for use with the Unix
operating system. C is a structured programming language, which means that it allows you to develop programs using well-defined control structures (you will
learn about control structures in the articles to come), and provides modularity (breaking the task into multiple sub tasks that are simple enough to understand
and to reuse). C is often called a middle-level language because it combines the best elements of low-level or machine language with high- level languages.

○ Where is C useful?

C‟s ability to communicate directly with hardware makes it a powerful choice for system programmers. In fact, popular operating systems such as Unix and
Linux are written entirely in C. Additionally, even compilers and interpreters for other languages such as FORTRAN, Pascal, and BASIC are written in C.
However, C‟s scope is not just limited to developing system programs. It is also used to develop any kind of application, including complex business ones.

The following is a partial list of areas where C language is used:

i. Embedded Systems
1) Systems Programming
2) Artificial Intelligence
3) Industrial Automation
ii. Computer Graphics
1) Space Research

○ Why you should learn C?

You should learn C because:

o C is simple.
o There are only 32 keywords so C is very easy to master. Keywords are words that have special meaning in C language.
o C programs run faster than programs written in most other languages.
o C enables easy communication with computer hardware making it easy to write system programs such as compilers and interpreters.

 WHY WE NEED DATA AND A PROGRAM

Any computer program has two entities to consider, the data, and the program. They are highly dependent on one another and careful planning of both will
lead to a well planned and well written program. Unfortunately, it is not possible to study either completely without a good working knowledge of the
other. For that reason, this tutorial will jump back and forth between teaching methods of program writing and methods of data definition. Simply follow
along and you will have a good understanding of both. Keep in mind that, even though it seems expedient to sometimes jump right into coding the program,
time spent planning the data structures will be well spent and the quality of the final program will reflect the original planning

 How to run a simple c program

a. Copy Turbo c/c++ in computer

b. Open c:\tc\bin\tc.exe
c. A window appears
d. Select File->new to open a new file
e. Type the following program on editor
f. Compile the program by pressing ALT+F9
g. Run the program by pressing CTRL +F9

 Note:

1. C is case sensitive
2. Always terminate statements with semicolon.
3. A program starts with main ()

 Explanation of program

#include is known as compiler directive. A compiler directive is a command to compiler to translate the program in a certain way. These statements are not
converted into machine language but only perform some other task.
main () is a function which the staring point for complier to start compilation. So a function must contain a main () function.

Pgramming in C Page 6
Features Of C
Friday, August 06, 2010
8:52 PM

FEATURES OF ‘C’
 C-Language keywords

Standard ANSI C recognizes the following keywords:

In addition to these standard keywords, TIGCC recognizes some extended keywords which do not exist in ANSI C, like asm, typeo f, inline, etc., which are described in
details in the section GNU C language extensions. This section also describes extensions to standard keywords, not only new o nes.

Note: If square brackets '[...]' are used in syntax descriptions, they mean optional arguments (as usual in syntax -describing languages), not square brackets as literals.

 auto
Defines a local variable as having a local lifetime.
Keyword auto uses the following syntax:
[auto] data-definition;

As the local lifetime is the default for local variables, auto keyword is extremely rarely used.

Note: GNU C extends auto keyword to allow forward declaration of nested functions.

 break
Passes control out of the compound statement.
The break statement causes control to pass to the statement following the innermost enclosing while, do, for, or switch statement. The syntax is simply
break;

 const
Makes variable value or pointer parameter unmodifiable.
When const is used with a variable, it uses the following syntax:
const variable-name [ = value];

In this case, the const modifier allows you to assign an initial value to a variable that cannot later be changed by the program. For example,
const my_age = 32;

Any assignments to 'my_age' will result in a compiler error. However, such declaration is quite different than using
#define my_age 32

In the first case, the compiler allocates a memory for 'my_age' and stores the initial value 32 there, but it will not allowany later assignment to this variable. But,
in the second case, all occurences of 'my_age' are simply replaced with 32 by the preprocessor, and no memory will be allocated for it.

Warning: a const variable can be indirectly modified by a pointer, as in the following example:
*(int*)&my_age = 35;

When the const modifier is used with a pointer parameter in a function's parameter list, it uses the following syntax:
function-name (const type *var-name)

Then, the function cannot modify the variable that the pointer points to. For example,
int printf (const char *format, ...);

Here the printf function is prevented from modifying the format string.

 continue
Passes control to the begining of the loop.
continue causes control to pass to the end of the innermost enclosing while, do, or for statement, at which point the loop continuation condition is re-evaluated.
The syntax is simply

Pgramming in C Page 7
 The syntax is simply
continue;

For example,
for (i = 0; i < 20; i++)
{
if (array[i] == 0)
continue;
array[i] = 1/array[i];
}

This example changes each element in the array with its reciprocal, but skips elements which are equal to zero.

 do
Do-while loop.
Keyword do is usually used together with while to make another form of repeating statement. Such form of the loop uses the following syntax:
do statement while (expression)
statement, which is usually a compound statement, is executed repeatedly as long as the value ofexpression remains non-zero. The test takes place after each
execution of the statement. For example,
i = 1; n = 1;
do
{
n *= i;
i++;
} while (i <= factorial);

 enum
Defines a set of constants of type int.
The syntax for defining constants using enum is
enum [tag] {name [=value], ...};

The set can optionally be given a type tag name with tag. name is the name of a constant that can optionally be assigned the (constant) value of value, etc. For
example,
enum Numbers {One = 1, Two = 2, Three = 3, Four = 4, Five = 5};

If value is missing, then a value is assumed to be the value of the previous constant in the list + 1. If this is the first constant in the list, the default value is 0.

If you give a type tag name, then you can declare variables of enumerated type using
enum tag variable-names;

For example,
enum Numbers x, y, z;

declares three variables x, y and z, all of type Numbers (they are, in fact, integer variables). More precise, 'enumtag' becomes a new type which is equal in rights
with any built-in type.

 extern
Indicates that an identifier is defined elsewhere.
Keyword extern indicates that the actual storage and initial value of a variable, or body of a function, is defined elsewhere, usually in a separate source code
module. So, it may be applied to data definitions and function prototypes:
extern data-definition;
extern function-prototype;

For example,
extern int _fmode;
extern void Factorial (int n);

The keyword extern is optional (i.e. default) for a function prototype.

 float, double
Floating point data types.
The keyword float usually represents a single precision floating point data type, and double represents a double precision floating point data type. In TIGCC, both
float and double (and even long double) are the same. The TI-89 and TI-92 Plus use a non-IEEE floating point format called SMAP II BCD for floating point values.

These values have a range from 1e-999 to 9.999999999999999e999 in magnitude, with a precision of exactly 16 significant digits. Principally, the exponent range
may be as high as 16383, but a lot of math routines do not accept exponents greater than 999.

 for
For loop.
For-loop is yet another kind of loop. It uses for keyword, with the following syntax:
for ([expr1]; [expr2]; [expr3]) statement

statement is executed repeatedly until the value of expr2is 0. Before the first iteration, expr1is evaluated. This is usually used to initialize variables for the loop.
After each iteration of the loop, expr3is evaluated. This is usually used to increment a loop counter. In fact, the for-loop is absolutely equivalent to the following
sequence of statements:
expr1;
while (expr2)

Pgramming in C Page 8
 {
statement;
expr3;
}

That's why expr1 and expr3must contain side effects, else they are useless. For example,
for (i=0; i<100; i++) sum += x[i];

for (i=0, t=string; i<40 && *t; i++, t++) putch(*t);

putch('\n');

for (i=0, sum=0, sumsq=0, i<100; i++)

{
sum += i; sumsq += i*i;
}

All the expressions are optional. If expr2is left out, it is assumed to be 1. statement may be a compound statement as well.

 goto
Unconditionally transfer control.
goto may be used for transfering control from one place to another. The syntax is:
goto identifier;

Control is unconditionally transferred to the location of a local label specified byidentifier. For example,
Again:
...
goto Again;

Jumping out of scope (for example out of the body of the for loop) is legal, but jumping into a scope (for example from one function to another) is not allowed.

Note: The GNU C extends the usage of goto keyword to allow computed goto. Also, it supports local labels, useful in macro definitions.

 if, else
Conditional statement.
Keyword if is used for conditional execution. The basic form of if uses the following syntax:
if (expression)
statement1

Alternatively, if may be used together with else, using the following syntax:
if (expression)
statement1
else
statement2

If expression is nonzero when evaluated, then statement1is executed. In the second case, statement2is executed if the expression is 0.

An optional else can follow an if statement, but no statements can come between an if statement and an else. Of course, bothstatement1and statement2may
be compound statements (i.e. a sequence of statements enclosed in braces). Here will be given some legal examples:
if (count < 50) count++;

if (x < y) z = x;
else z = y;

if (x < y)
{
printf ("x is smaller");
return x;
}
else
{
printf ("x is greater")
return y;
}

The #if and #else preprocessor statements look similar to the if and else statements, but have very different effects. They control which source file lines are
compiled and which are ignored.

 int, char
Basic data types (integer and character).
Variables of type int are one machine-type word in length. They can be signed (default) or unsigned, which means that in this configuration of the compiler they
have by default a range of -32768 to 32767 and 0 to 65535 respectively, but this default may be changed if the compiler option'-mnoshort' is given. In this case,
the range of type int is -2147483648 to 2147483647 for signed case, or 0 to 4294967295 for unsigned case. See also short and long type modifiers.

Variables of type char are 1 byte in length. They can be signed (this is the default, unless you use the compiler option'-funsigned-char') or unsigned, which
means they have a range of -128 to 127 and 0 to 255, respectively.

All data types may be used for defining variables, specifying return types of functions, and specifying types of function arguments. For example,
int a, b, c; // 'a', 'b', 'c' are integer variables
int func (); // 'func' is a function returning int
char crypt (int key, char value); // 'crypt' is a function returning char with
// two args: 'key' is int and 'value' is char

Pgramming in C Page 9
 When function return type is omitted, int is assumed.

All data type keywords may be used in combination with asterisks, brackets and parentheses, for making complex data types, like pointer types, array types,
function types, or combinations of them, which in the C language may have an arbitrary level of complexity (see asterisk formore info).

 register
Tells the compiler to store the variable being declared in a CPU register.
In standard C dialects, keyword auto uses the following syntax:
register data-definition;

The register type modifier tells the compiler to store the variable being declared in a CPU register (if possible), to optimize access. For example,
register int i;

Note that TIGCC will automatically store often used variables in CPU registers when the optimization is turned on, but the keyword register will force storing in
registers even if the optimization is turned off. However, the request for storing data in registers may be denied, if the compiler concludes that there is not
enough free registers for use at this place.

Note: The GNU C extends the usage of register keyword to allow explicitely choosing of used registers.

 return
Exits the function.
return exits immediately from the currently executing function to the calling routine, optionally returning a value. The syntax is:
return [expression];

For example,
int sqr (int x)
{
return (x*x);
}

 short, long, signed, unsigned

Type modifiers.
A type modifier alters the meaning of the base type to yield a new type. Each of these type modifiers can be applied to the base type int. The modifiers signed
and unsigned can be applied to the base type char. In addition, long can be applied to double.

When the base type is omitted from a declaration, int is assumed. For example,
long x; // 'int' is implied
unsigned char ch;
signed int i; // 'signed' is default
unsigned long int l; // 'int' is accepted, but not needed

In this implementation of the compiler, the valid range of valid data types is as listed in the following table:
short int -32768 to 32767
long int -2147483648 to 2147483647
signed char -128 to 127
signed int -32768 to 32767 (signed is default)
[or -2147483648 to 2147483647 if '-mnoshort' is given]
signed short int -32768 to 32767
signed long int -2147483648 to 2147483647
unsigned char 0 to 255
unsigned int 0 to 65535
[or 0 to 4294967295 if '-mnoshort' is given]
unsigned short int 0 to 65535
unsigned long int 0 to 4294967295

Note: GNU C extends the long keyword to allow double-long integers (64-bit integers in this implementation), so they have range from -9223372036854775808
to 9223372036854775807 if signed, or from 0 to 18446744073709551615 if unsigned.

 sizeof
Returns the size of the expression or type.
Keyword sizeof is, in fact, an operator. It returns the size, in bytes, of the given expression or type (as type size_t). Itsargument may be an expression of a type
name:
sizeof expression
sizeof (type)

For example,
workspace = calloc (100, sizeof (int));
memset(buff, 0, sizeof buff);
nitems = sizeof (table) / sizeof (table[0]);

Note that type may be an anonymous type (see asterisk for more info about anonymous types).

 static
Preserves variable value to survive after its scope ends.
Keyword static may be applied to both data and function definitions:
static data-definition;

Pgramming in C Page 10
 static function-definition;

For example,
static int i = 10;
static void PrintCR (void) { putc ('\n'); }

static tells that a function or data element is only known within the scope of the current compile. In addition, if you use the static keyword with a variable that is
local to a function, it allows the last value of the variable to be preserved between successive calls to that function.

Note that the initialization of automatic and static variables is quite different. Automatic variables (local variables are automatic by default, except you explicitely
use static keyword) are initialized during the run-time, so the initialization will be executed whenever it is encountered in the program. Static (and global)
variables are initialized during the compile-time, so the initial values will simply be embeded in the executable file itself. If you change them, they will retain
changed in the file. By default, the C language proposes that all uninitialized static variables are initialized to zero, butdue to some limitations in TIGCC linker, you
need to initialize explicitely all static and global variables if you compile the program in "nostub" mode.

The fact that global and static variables are initialized in compile-time and kept in the executable file itself has one serious consequence, which is not present on
"standard" computers like PC, Mac, etc. Namely, these computers always reload the executable on each start from an external memory device (disk), but this is
not the case on TI. So, if you have the following global (or static) variable
int a = 10;

and if you change its value somewhere in the program to 20 (for example), its initial value will be 20 (not 10) on the next program start! Note that this is true only
for global and static variables. To force reinitializing, you must put explicitely something like
a = 10;

at the begining of the main program!

Note, however, that if the program is archived, the initial values will be restored each time you run the program, because archived programs are reloaded from
the archive memory to the RAM on each start, similarly like the programs are reloaded from disks on "standard" computers eachtime when you start them.

 struct
Groups variables into a single record.
The syntax for defining records is:
struct [struct-type-name]
{
[type variable-names] ;
...
} [structure-variables] ;

A struct, like an union, groups variables into a single record. The struct-type-name is an optional tag name that refers to the structure type. The structure-
variables are the data definitions, and are also optional. Though both are optional, one of the two must appear.

Elements in the record are defined by naming a type, followed by variable-names separated by commas. Different variable types can be separated by a
semicolon. For example,
struct my_struct
{
char name[80], phone_number[80];
int age, height;
} my_friend;

declares a record variable my_friend containing two strings (name and phone_number) and two integers (age and height). To declare additional variables of the
same type, you use the keyword struct followed by the struct-type-name, followed by the variable names. For example,
struct my_struct my_friends[100];

declares an array named my_friends which components are records. In fact, 'struct my_struct' becomes a new type which is equal in rights with any built-in type.

To access elements in a structure, you use a record selector ('.'). For example,
strcpy (my_friend.name, "Mr. Wizard");

A bit field is an element of a structure that is defined in terms of bits. Using a special type of struct definition, you candeclare a structure element that can range
from 1 to 16 bits in length. For example,
struct bit_field
{
int bit_1 : 1;
int bits_2_to_5 : 4;
int bit_6 : 1;
int bits_7_to_16 : 10;
} bit_var;

 switch, case, default

Branches control.
switch causes control to branch to one of a list of possible statements in the block of statements. The syntax is
switch (expression) statement

The statement statement is typically a compound statement (i.e. a block of statements enclosed in braces). The branched-to statement is determined by
evaluating expression, which must return an integral type. The list of possible branch points withinstatement is determined by preceding substatements with
case constant-expression :

where constant-expressionmust be an int and must be unique.

Once a value is computed for expression, the list of possible constant-expression values determined from all case statements is searched for a match. If a match is
found, execution continues after the matching case statement and continues until a break statement is encountered or the endof statement is reached. If a
match is not found and this statement prefix is found within statement,

Pgramming in C Page 11
 default :

execution continues at this point. Otherwise, statement is skipped entirely. For example,
switch (operand)
{
case MULTIPLY:
x *= y; break;
case DIVIDE:
x /= y; break;
case ADD:
x += y; break;
case SUBTRACT:
x -= y; break;
case INCREMENT2:
x++;
case INCREMENT1:
x++; break;
case EXPONENT:
case ROOT:
case MOD:
printf ("Not implemented!\n");
break;
default:
printf("Bug!\n");
exit(1);
}

See also break.

Note: GNU C extends the case keyword to allow case ranges.

 typedef
Creates a new type.
The syntax for defining a new type is
typedef type-definition identifier;
This statement assigns the symbol name identifier to the data type definition type-definition. For example,
typedef unsigned char byte;
typedef char str40[41];
typedef struct {float re, im;} complex;
typedef char *byteptr;
typedef int (*fncptr)(int);

After these definition, you can declare

byte m, n;
str40 myStr;
complex z1, z2;
byteptr p;
fncptr myFunc;

with the same meaning as you declare

unsigned char m, n;
char myStr[41];
struct {float re, im;} z1, z2;
char *p;
int (*myFunc)(int);

User defined types may be used at any place where the built-in types may be used.

 union
Groups variables which share the same storage space.
A union is similar to a struct, except it allows you to define variables that share storage space. The syntax for defining unions is:
union [union-type-name]
{
type variable-names;
...
} [union-variables] ;

For example,
union short_or_long
{
short i;
long l;
} a_number;

The compiler will allocate enough storage in a number to accommodate the largest element in the union. Elements of a union are accessed in the same manner
as a struct.

Unlike a struct, the variables 'a_number.i' and 'a_number.l' occupy the same location in memory. Thus, writing into one willoverwrite the other.

 void
Empty data type.

Pgramming in C Page 12
 Empty data type.
When used as a function return type, void means that the function does not return a value. For example,
void hello (char *name)
{
printf("Hello, %s.", name);
}

When found in a function heading, void means the function does not take any parameters. For example,
int init (void)
{
return 1;
}

This is not the same as defining

int init ()
{
return 1;
}

because in the second case the compiler will not check whether the function is really called with no arguments at all; instead, a function call with arbitrary
number of arguments will be accepted without any warnings (this is implemented only for the compatibility with the old-style function definition syntax).

Pointers can also be declared as void. They can't be dereferenced without explicit casting. This is because the compiler can't determine the size of the object the
pointer points to. For example,
int x;
float f;
void *p = &x; // p points to x
*(int*)p = 2;
p = &r; // p points to r
*(float*)p = 1.1;

 volatile
Indicates that a variable can be changed by a background routine.
Keyword volatile is an extreme opposite of const. It indicates that a variable may be changed in a way which is absolutely unpredictable by analysing the normal
program flow (for example, a variable which may be changed by an interrupt handler). This keyword uses the following syntax:
volatile data-definition;

Every reference to the variable will reload the contents from memory rather than take advantage of situations where a copy can be in a register.

 while
Repeats execution while the condition is true.
Keyword while is the most general loop statemens. It uses the following syntax:
while (expression) statement

statement is executed repeatedly as long as the value of expression remains nonzero. The test takes place before each execution of the statement. For example,
while (*p == ' ') p++;

Of course, statement may be a compound statement as well.

Pgramming in C Page 13
Data Types
Friday, August 06, 2010
9:11 PM

Data Types
A C language programmer has to tell the system before-hand, the type of numbers or characters he is using in his program. These are data types.
There are many data types in C language. A C programmer has to use appropriate data type as per his requirement.

C language data types can be broadly classified as -

o Primary data type
o Derived data type
o User defined data type

1. Primary data type

S.no Data Types Description Range Format
1. Integer Stores signed integers. e.g.:, positive or negative integers. -32768 to + int
32767
2. Character Stores a single character belonging to the defined character -128 to 127 char
set of C language.
3. Floating Point Stores real numbers with single precision ( Precision of six 3.4 e-38 to 3.4 float
digits after decimal points) e+38
4. Double precision Stores real numbers with double precision, i.e., Twice the 1.7 e-308 to 1.7 double
floating point storage e+308
Space required by float.
5. Void Specify no Values void

 Integer Type:
Integers are whole numbers with a machine dependent range of values. A good programming language as to support the programmer by giving a control on
a range of numbers and storage space. C has 3 classes of integer storage namely short int, int and long int. All of these data types have signed and unsigned
forms. A short int requires half the space than normal integer values. Unsigned numbers are always positive and consume all the bits for the magnitude of
the number. The long and unsigned integers are used to declare a longer range of values.

 Floating Point Types:

Floating point number represents a real number with 6 digits precision. Floating point numbers are denoted by the keyword float. When the accuracy of the
floating point number is insufficient, we can use the double to define the number. The double is same as float but with longer precision. To extend the
precision further we can use long double which consumes 80 bits of memory space.

 Void Type:
Using void data type, we can specify the type of a function. It is a good practice to avoid functions that does not return any values to the calling function.

 Character Type:
A single character can be defined as a defined as a character type of data. Characters are usually stored in 8 bits of internal storage. The qualifier signed or
unsigned can be explicitly applied to char. While unsigned characters have values between 0 and 255, signed characters have values from –128 to 127.

Size and Range of Data Types on 16 bit machine.

type SIZE (Bits) Range

Pgramming in C Page 14
 type SIZE (Bits) Range

Char or Signed Char 8 -128 to 127

Unsigned Char 8 0 to 255

int or Signed int 16 -32768 to 32767

Unsigned int 16 0 to 65535

Short int or Signed short int 8 -128 to 127

Unsigned short int 8 0 to 255

Long int or signed long int 32 -2147483648 to

2147483647

Unsigned long int 32 0 to 4294967295

Float 32 3.4 e-38 to 3.4 e+38

Double 64 1.7e-308 to 1.7e+308

Long Double 80 3.4 e-4932 to 3.4 e+4932

Note: Use of unsigned variable

When declaring a numeric variable in c , you can use 'signed' or 'unsigned'. Variable is signed unless you specifically type unsigned before the variable type.
e.g.: unsigned int sh = 26;
i. The standard int variable can hold values from -32,768 to 32,767.
ii. That's half negative numbers, from -32,768 to -1, And then half positive numbers, from 0 to up to 32,767.
iii. An unsigned number means that the variable holds only positive values.
iv. Your typical unsigned int has a range from 0 to 65,535.

2. Derived Data Type (or Composite Data Type)

There are five Composite data types, also known as Derived data type or Secondary data type. Composite data types are derived
from the basic data type.

 Array
Sequence of objects, All of which are of same types and have same name,
e.g..: int num[5];
Reserves sequence of five locations of 2 bytes, each, for storing integer num[0],num[1],num[2],num[3], and num[4].
 Pointers
Used to store the address of any memory location.
 Structure
Collection of variables of different types.
e.g.: A structure of employee's data. i.e., name, age, salary.
 Union
Collection of variables of different types sharing common memory space.
 Enumerated
Its members are the constants that are written as identifiers though data type they have signed integer values. These
constants represent values that can be assigned to corresponding enumeration variables.
Enumeration may be define as enum tag{member1, member2…….member n};
e.g.: enum colors {red, green, blue, cyan};
Colors foreground, background;
The first line an enumeration named "colors" which may have any one of the four colors defined in the curly braces. In the
second line, variables of the enumerated data type "colors" are declared.

3. User Defined Data Type

Pgramming in C Page 15
Variable
Friday, August 06, 2010
10:26 PM

Variable
Variable is a name of memory location where we can store any data. It can store only single data (Latest data) at a time. In C, a variable must be
declared
before it can be used. Variables can be declared at the start of any block of code, but most are found at the start of each function.
A declaration begins with the type, followed by the name of one or more variables. For example,
Data Type Name_of_Variable_Name;

int a,b,c;

 Variable Names
Every variable has a name and a value. The name identifies the variable, the value stores data. There is a limitation on what these names can be. Every
variable name in C must start with a letter; the rest of the name can consist of letters, numbers and underscore characters. C recognizes upper and lower
case characters as being different. Finally, you cannot use any of C's keywords like main, while, switch etc as variable names.
Examples of legal variable names include:

x result outfile bestyet

x1 x2 out_file best_yet
power impetus gamma hi_score

It is conventional to avoid the use of capital letters in variable names. These are used for names of constants. Some old implementations of C only use the first 8
characters of a variable name.

 Local Variables
Local variables are declared within the body of a function, and can only be used within that function only.
Syntax:

Void main( )
{
int a,b,c;
}

Void fun1()
{
int x,y,z;
}

Here a,b,c are the local variable of void main() function and it can‟t be used within fun1() Function. And x, y and z are local variable of fun1().

 Global Variable

A global variable declaration looks normal, but is located outside any of the program's functions. This is usually done at the beginning of the program file,
but after preprocessor directives. The variable is not declared again in the body of the functions which access it.
Syntax:
#include<stdio.h>

int a,b,c;
void main()
{

}
Void fun1()
{
}
Here a,b,c are global variable .and these variable cab be accessed (used) within a whole program.

Pgramming in C Page 16
 Constants
Friday, August 06, 2010
10:29 PM

Constants
C constant is usually just the written version of a number. For example 1, 0, 5.73, 12.5e9. We can specify our constants in octal or hexadecimal, or force
them to be treated as long integers.
o Octal constants are written with a leading zero - 015.
o Hexadecimal constants are written with a leading 0x - 0x1ae.
o Long constants are written with a trailing L - 890L.
Character constants are usually just the character enclosed in single quotes; 'a', 'b', 'c'. Some characters can't be represented in this way, so we use a 2 character
sequence.
'\n' Newline
'\t' Tab
'\\' Backslash
'\'' Single quote
'\0' Null (used automatically to terminate character strings).

In addition, a required bit pattern can be specified using its octal equivalent.
'\044' produces bit pattern 00100100.
Character constants are rarely used, since string constants are more convenient. A string constant is surrounded by double quotes e.g. "Brian and Dennis". The
string is actually stored as an array of characters. The null character '\0' is automatically placed at the end of such a string to act as a string terminator.
Constant is a special types of variable which can not be changed at the time of execution. Syntax:
const int a=20;

► Types of Constants:

a. Character Constants
A Character constant consists of a single character, single digits, or a single special symbol enclosed within a pair of single inverted commas.
The maximum length of a character constant is one character.
b. Integer constant
An integer constant refers to a sequence of digits and has a numeric value. There are three types of integers in C language: decimal, octal,
hexadecimal.
c. Real or Floating Point Constants
A number with a decimal point and an optional preceding sign represents a real constant.
Note: that 7 is an integer while 7. or 7.0 is real.
Another notation (called scientific notation) for real constants consists of three parts:
1) A sign (+ or 0) preceding the number portion (optional).
2) A number portion.
3) An exponent portion following the number portion (optional). It starts with E or e followed by an integer. Which may or may not be preceded by
a sign.
d. String constants
A string constant is a sequence of one or more character enclosed within a pair of double quotes (""). If a single character is enclosed within a pair of
double quotes, it will also be interpreted a s a string constant and not a character constant.
e. Logical Constants
A logical constant can have either true value or false value. In C, a non zero value is treated as true while 0 is treated a s false.

Pgramming in C Page 17
Operators
Friday, August 06, 2010
11:12 PM

Operators
• Operators Introduction

An operator is a symbol which helps the user to command the computer to do a certain mathematical or logical manipulations. Operators are used in C
language program to operate on data and variables. C has a rich set of operators which can be classified as:

○ Arithmetic operators
○ Relational Operators
○ Logical Operators
○ Assignment Operators
○ Increments and Decrement Operators
○ Conditional Operators
○ Bitwise Operators
○ Special Operators

Overview of the C Operators

Variables and constants can be used in conjunction with C operators to create more complex expressions. Table 6-1 presents the set of C operators.

Table 6-1 C Operators

Operator Example Description/Meaning

() f() Function call
[] a[10] Array reference
-> s->a 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
+ [binary] a+ b a plus b
- [binary] a- b a minus b
* [binary] a* b a times b
/% 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)

Pgramming in C Page 18
 %= 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)

The C operators fall into the following categories:

• Postfix operators, which follow a single operand.
• Unary prefix operators, which precede a single operand.
• Binary operators, which take two operands and perform a variety of arithmetic and logical operations.
• The conditional operator (a ternary operator), which takes three operands and evaluates either the second or third expression , depending on the evaluation of
the first expression.
• Assignment operators, which assign a value to a variable.
• The comma operator, which guarantees left-to-right evaluation of comma-separated expressions.
Operator precedence determines the grouping of terms in an expression. This affects how an expression is evaluated. Certain operators have higher precedence than
others; for example, the multiplication operator has higher precedence than the addition operator:
x = 7 + 3 * 2; /* x is assigned 13, not 20 */

The previous statement is equivalent to the following:

x = 7 + ( 3 * 2 );

Using parenthesis in an expression alters the default precedence. For example:

x = (7 + 3) * 2; /* (7 + 3) is evaluated first */

In an unparenthesized expression, operators of higher precedence are evaluated before those of lower precedence. Consider the following expression:
A+B*C

The identifiers B and C are multiplied first because the multiplication operator (*) has higher precedence than the addition operator (+).
Table 6-2 shows the precedence the compiler uses to evaluate the C operators. Operators with the highest precedence appear at the top of the table; those with the
lowest appear at the bottom. Operators of equal precedence appear in the same row.

Table 6-2 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

Associativity relates to precedence, and resolves any ambiguity over the grouping of operators with the same precedence. In the following statement, the rules of C
specify that a * b is evaluated first:
y = a * b / c;

In a more complicated example, associativity rules specify that b ? c : d is evaluated first in the following example:
a ? b ? c : d : e;

The associativity of the conditional operator is right-to-left on the line. The assignment operator also associates right-to-left; for example:
int x = 0 , y = 5, z = 3;
x = y = z; /* x has the value 3, not 5 */

Other operators associate left-to-right; for example, the binary addition, subtraction, multiplication, and division operators all have left-to-right associativity.
Associativity applies to each row of operators In table 6-2 and is right-to-left for some rows and left-to-right for others. The kind of associativity determines the order
in which operators from the same row are evaluated in an unparenthesized expression. Consider the following expression:
A*B%C

This expression is evaluated as follows because the multiplicative operators (*, /, %) are evaluated from left to right:
(A*B)%C

Parentheses can always be used to control precedence and associativity within an expression.

Pgramming in C Page 19
 C Language Operator Precedence Chart
Operator precedence describes the order in which C reads expressions. For example, the expression a=4+b*2 contains two operations, an
addition and a multiplication. Does the C compiler evaluate 4+b first, then multiply the result by 2, or does it evaluate b*2 first, then add 4 to the
result? The operator precedence chart contains the answers. Operators higher in the chart have a higher precedence, meaning that the C compiler
evaluates them first. Operators on the same line in the chart have the same precedence, and the "Associatively" column on the right gives their
evaluation order.

Operator Precedence Chart

Operator Type Operator Associatively

Primary Expression Operators () [] . -> expr++ expr-- left-to-right
Unary Operators * & + - ! ~ ++expr --expr (typecast) sizeof() right-to-left
Binary Operators * / % left-to-right
+ -

>> <<

< > <= >=

== !=

&

&&

||

Ternary Operator ?: right-to-left

Assignment Operators = += -= *= /= %= >>= <<= &= ^= |= right-to-left
Comma , left-to-right

Pgramming in C Page 20
Arithmetic operators
Friday, August 06, 2010
11:23 PM

Arithmetic Operators
All the basic arithmetic operations can be carried out in C. All the operators have almost the same meaning as in other langu ages. Both unary and binary
operations are available in C language. Unary operations operate on a singe operand, therefore the number 5 when operated by unary – will have the value –5.

Arithmetic Operators
Operator Meaning

+ Addition or Unary Plus

– Subtraction or Unary M inus

* M ultiplication

/ Division

% M odulus Operator

Examples of arithmetic operators are

x+ y
x-y
-x + y
a* b + c
-a * b
etc.,

here a, b, c, x, y are known as operands. The modulus operator is a special operator in C language which evaluates the remainder of the operands after division.

Example
.
#include //include header file stdio.h
void main() //tell the compiler the start of the program
{
int numb1, num2, sum, sub, mul, div, mod; //declaration of variables
scanf (“%d %d”, &num1, &num2); //inputs the operands

sum = num1+num2; //addition of numbers and storing in sum.

printf(“\n Thu sum is = %d”, sum); //display the output

sub = num1-num2; //subtraction of numbers and storing in sub.

printf(“\n Thu difference is = %d”, sub); //display the output

mul = num1*num2; //multiplication of numbers and storing in mul.

printf(“\n Thu product is = %d”, mul); //display the output

div = num1/num2; //division of numbers and storing in div.

printf(“\n Thu division is = %d”, div); //display the output

mod = num1%num2; //modulus of numbers and storing in mod.

printf(“\n Thu modulus is = %d”, mod); //display the output
}
.

Integer Arithmetic
When an arithmetic operation is performed on two whole numbers or integers than such an operation is called as integer arithm etic. It always gives an integer as
the result. Let x = 27 and y = 5 be 2 integer numbers. Then the integer operation leads to the following results.

x + y = 32
x – y = 22
x * y = 115
x%y = 2
x/y = 5

In integer division the fractional part is truncated.

Floating point arithmetic

When an arithmetic operation is preformed on two real numbers or fraction numbers such an operation is called floating point arithmetic. The floating point
results can be truncated according to the properties requirement. The remainder operator is not applicable for floating point arithmetic operands.

Let x = 14.0 and y = 4.0 then

x + y = 18.0
x – y = 10.0
x * y = 56.0

Pgramming in C Page 21
x * y = 56.0
x / y = 3.50

Mixed mode arithmetic

When one of the operand is real and other is an integer and if the arithmetic operation is carried out on these 2 operands th en it is called as mixed mode
arithmetic. If any one operand is of real type then the result will always be real thus 15/10.0 = 1.5

Pgramming in C Page 22
Relational Operator
Friday, August 06, 2010
11:29 PM

Relational Operators
Often it is required to compare the relationship between operands and bring out a decision and program accordingly. This is when the relational
operator come into picture. C supports the following relational operators.

Operator Meaning

< is less than

<= is less than or equal to

> is greater than

>= is greater than or equal to

== is equal to

It is required to compare the marks of 2 students, salary of 2 persons, we can compare them using relational operators.

A simple relational expression contains only one relational operator and takes the following form.

exp1 relational operator exp2

Where exp1 and exp2 are expressions, which may be simple constants, variables or combination of them. Given below is a list of examples of relational
expressions and evaluated values.

6.5 <= 25 TRUE

-65 > 0 FALSE
10 < 7 + 5 TRUE

Relational expressions are used in decision making statements of C language such as if, while and for statements to decide the course of action of a running
program.

Pgramming in C Page 23
Logical Operators
Friday, August 06, 2010
11:29 PM

Logical Operators
C has the following logical operators, they compare or evaluate logical and relational expressions.
Operator Meaning

&& Logical AND

|| Logical OR

! Logical NOT

Logical AND (&&)

This operator is used to evaluate 2 conditions or expressions with relational operators simultaneously. If both the expressions to the left and to the right of the
logical operator is true then the whole compound expression is true.

Example
a > b && x = = 10

The expression to the left is a > b and that on the right is x == 10 the whole expression is true only if both expressions are true i.e., if a is greater than b and x is
equal to 10.

Logical OR (||)
The logical OR is used to combine 2 expressions or the condition evaluates to true if any one of the 2 expressions is true.

Example
a < m || a < n

The expression evaluates to true if any one of them is true or if both of them are true. It evaluates to true if a is less than either m or n and when a is less than both
m and n.

Logical NOT (!)

The logical not operator takes single expression and evaluates to true if the expression is false and evaluates to false if the expression is true. In other words it
just reverses the value of the expression.

For example
! (x >= y) the NOT expression evaluates to true only if the value of x is neither greater than or equal to y

Pgramming in C Page 24
Assignment Operators
Friday, August 06, 2010
11:29 PM

Assignment Operators
The Assignment Operator evaluates an expression on the right of the expression and substitutes it to the value or variable on the left of the expression.

Example
x= a+ b
Here the value of a + b is evaluated and substituted to the variable x.

In addition, C has a set of shorthand assignment operators of the form.

var oper = exp;

Here var is a variable, exp is an expression and oper is a C binary arithmetic operator. The operator oper = is known as shorthand assignment operator
Example

x + = 1 is same as x = x + 1

The commonly used shorthand assignment operators are as follows

Shorthand assignment operators .

Statement with simple Statement with

assignment operator shorthand operator

a= a + 1 a += 1

a= a – 1 a -= 1

a = a * (n+1) a *= (n+1)

a = a / (n+1) a /= (n+1)

a= a % b a %= b

Example for using shorthand assignment operator

.
#define N 100 //creates a variable N with constant value 100
#define A 2 //creates a variable A with constant value 2

main() //start of the program

{
int a; //variable a declaration
a = A; //assigns value 2 to a

while (a < N) //while value of a is less than N

{ //evaluate or do the following
printf(“%d \n”,a); //print the current value of a
a *= a; //shorthand form of a = a * a
} //end of the loop
} //end of the program
.

Output

2
4
16

Pgramming in C Page 25
 Increment And Decrement Operators
Saturday, August 07, 2010
10:23 AM

Increment and Decrement Operators

The increment and decrement operators are one of the unary operators which are very useful in C language. They are extensively used in for and while
loops.
The syntax of the operators is given below
1. ++ variable name
2. variable name++
3. – –variable name
4. variable name– –

The increment operator ++ adds the value 1 to the current value of operand and the decrement operator – – subtracts the value 1 from the current value of
operand. ++variable name and variable name++ mean the same thing when they form statements independently, they behave differently when they are used in
expression on the right hand side of an assignment statement.

Consider the following .

m = 5;
y = ++m; (prefix)

In this case the value of y and m would be 6

Suppose if we rewrite the above statement as

m = 5;
y = m++; (post fix)

Then the value of y will be 5 and that of m will be 6. A prefix operator first adds 1 to the operand and then the result is assigned to the variable on the left. On the
other hand, a postfix operator first assigns the value to the variable on the left and then increments the operand.

 NOTE :
Prefix: the value is incremented/decremented first and then applied.
Postfix: the value is applied and the value is incremented/decremented.

Pgramming in C Page 26
Conditional or Ternary Operators
Saturday, August 07, 2010
10:28 AM

Conditional or Ternary Operator

The conditional operator consists of 2 symbols the question mark (?) and the colon (:)
The syntax for a ternary operator is as follows .

exp1 ? exp2 : exp3

The ternary operator works as follows

exp1 is evaluated first. If the expression is true then exp2 is evaluated & its value becomes the value of the expression. If exp1 is false, exp3 is evaluated and its
value becomes the value of the expression. Note that only one of the expression is evaluated.

For example

a = 10;
b = 15;
x = (a > b) ? a : b

Here x will be assigned to the value of b. The condition follows that the expression is false therefore b is assigned to x.
.
/* Example : to find the maximum value using conditional operator) */
#include<stdio.h>
void main() //start of the program
{
int i,j,larger; //declaration of variables
printf (“Input 2 integers : ”); //ask the user to input 2 numbers
scanf(“%d %d”,&i, &j); //take the number from standard input and store it
larger = i > j ? i : j; //evaluation using ternary operator
printf(“The largest of two numbers is %d \n”, larger); // print the largest number
} // end of the program
.

Output
Input 2 integers : 34 45
The largest of two numbers is 45

Pgramming in C Page 27
Bitwise Operators
Saturday, August 07, 2010
10:31 AM

Bitwise Operators
C has a distinction of supporting special operators known as bitwise operators for manipulation data at bit level. A bitwise operator operates on each bit
of data. Those operators are used for testing, complementing or shifting bits to the right on left. Bitwise operators may not be applied to a float or double.

Operator Meaning

& Bitwise AND

| Bitwise OR

^ Bitwise Exclusive

<< Shift left

>> Shift right

Pgramming in C Page 28
 Special Operators
Saturday, August 07, 2010
10:31 AM

Special Operators
C supports some special operators of interest such as comma operator, size of operator, pointer operators (& and *) and member selection operators (.
and ->). The size of and the comma operators are discussed here. The remaining operators are discussed in forth coming chapters.

1. The Comma Operator

The comma operator can be used to link related expressions together. A comma -linked list of expressions are evaluated left to right and value of right most
expression is the value of the combined expression.
For example the statement
value = (x = 10, y = 5, x + y);
First assigns 10 to x and 5 to y and finally assigns 15 to value. Since comma has the lowest precedence in operators the parenthesis is necessary. Some
examples of comma operator are
In for loops:
for (n=1, m=10, n <=m; n++,m++)
In while loops
While (c=getchar(), c != „10‟)
Exchanging values.
t = x, x = y, y = t;

2. The size of Operator

The operator size of gives the size of the data type or variable in terms of bytes occupied in the memory. The operand may be a variable, a constant or a
data type qualifier.
Example
m = sizeof (sum);
n = sizeof (long int);
k = sizeof (235L);
The size of operator is normally used to determine the lengths of arrays and structures when their sizes are not known to the programmer. It is also used to
allocate memory space dynamically to variables during the execution of the program.
Example program that employs different kinds of operators. The results of their evaluation are also shown in comparision .
.main() //start of program
{
int a, b, c, d; //declaration of variables
a = 15; b = 10; c = ++a-b; //assign values to variables
printf (“a = %d, b = %d, c = %d\n”, a,b,c); //print the values
d=b++ + a;
printf (“a = %d, b = %d, d = %d\n, a,b,d);
printf (“a / b = %d\n, a / b);
printf (“a %% b = %d\n, a % b);
printf (“a *= b = %d\n, a *= b);
printf (“%d\n, (c > d) ? 1 : 0 );
printf (“%d\n, (c < d) ? 1 : 0 );
}

Notice the way the increment operator ++ works when used in an expression. In the statement c = ++a – b; new value a = 16 is used thus giving value 6 to
C. That is a is incremented by 1 before using in expression.
However in the statement d = b++ + a; The old value b = 10 is used in the expression. Here b is incremented after it is used in the expression.

We can print the character % by placing it immediately after another % character in the control string. This is illustrated b y the statement.

printf(“a %% b = %d\n”, a%b);

This program also illustrates that the expression

c> d ? 1 : 0

Assumes the value 0 when c is less than d and 1 when c is greater than d.

Pgramming in C Page 29
 The Input And Output
Saturday, August 07, 2010
10:55 AM

Input and Output

Input and output are covered in some detail. C allows quite precise control of these. This section discusses input and output from keyboard and screen.
The same mechanisms can be used to read or write data from and to files. It is also possible to treat character strings in a similar way, constructing or analysing
them and storing results in variables. These variants of the basic input and output commands are discussed in the next sectio n

 The Standard Input Output File

o Character Input / Output
□ getchar
□ putchar
o Formatted Input / Output
□ printf
□ scanf
o Whole Lines of Input and Output
□ gets
□ puts

1. Character Input/output
a. getchar
getchar returns the next character of keyboard input as an int. If there is an error then EOF (end of file) is returned instead. It is therefore usual to
compare this value against EOF before using it. If the return value is stored in a char, it will never be equal to EOF, so error conditions will not be handled
correctly.
As an example, here is a program to count the number of characters read until an EOF is encountered. EOF can be generated by typing Control - d.

#include <studio.h>

main()
{ int ch, i = 0;

while((ch = getchar()) != EOF)

i ++;

printf("%d\n", i);
}

b. putchar
putchar puts its character argument on the standard output (usually the screen).
The following example program converts any typed input into capital letters. To do this it applies the function to upper from the character conversion
library c type .h to each character in turn.
#include <ctype.h> /* For definition of toupper */
#include <stdio.h> /* For definition of getchar, putchar, EOF */

main()
{
char ch;

while((ch = getchar()) != EOF)

putchar (toupper(ch));
}

2. Formatted Input / Output

a. printf
This offers more structured output than putchar. Its arguments are, in order; a control string, which controls what gets printed, followed by a list of
values to be substituted for entries in the control string
Example: int a,b;
printf(“ a = %d,b=%d”,a,b);.

Control String Entry What Gets Printed

%d A decimal integer
%f A floating point value
%c A character
%s A character string

It is also possible to insert numbers into the control string to control field widths for values to be displayed. For example %6d would print a decimal
value in a field 6 spaces wide, %8.2f would print a real value in a field 8 spaces wide with room to show 2 decimal places. Display is left justified by
default, but can be right justified by putting a - before the format information, for example %-6d, a decimal integer right justified in a 6 space field
b. scanf
scanf allows formatted reading of data from the keyboard. Like printf it has a control string, followed by the list of items to be read. However scanf
wants to know the address of the items to be read, since it is a function which will change that value. Therefore the names of variables are preceded by the
& sign. Character strings are an exception to this. Since a string is already a character pointer, we give the names of string variables unmodified by a
leading &. Control string entries which match values to be read are preceeded by the percentage sign in a similar way to their printf equivalents.
Example: int a,b;
scan f(“%d%d”,& a,& b);

Pgramming in C Page 30
3. Whole Lines of Input and Output
a. gets
gets reads a whole line of input into a string until a new line or EOF is encountered. It is critical to ensure that the string is large enough to hold any
expected input lines. When all input is finished, NULL as defined in studio is returned.
#include <stdio.h>

main()
{
char ch[20];

gets(x);
puts(x);
}

b. puts
puts writes a string to the output, and follows it with a new line character.
Example: Program which uses gets and puts to double space typed input.

#include <stdio.h>
main()
{
char line[256]; /* Define string sufficiently large to
store a line of input */

while(gets(line) != NULL) /* Read line */

{
puts(line); /* Print line */
printf("\n"); /* Print blank line */
}
}

Note that putchar, printf and puts can be freely used together

Pgramming in C Page 31
Expression Statements
Saturday, August 07, 2010
11:23 AM

Expression Statements
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!\n");
are all expression statements. (In some languages, such as Pascal, the semicolon separates statements, such that the last statement is not followed by a
semicolon. In C, however, the semicolon is a statement terminator; all simple statements are followed by semicolons. The semicolon is also used for a few
other things in C; we've already seen that it terminates declarations, too.

Pgramming in C Page 32
 Control Flow Statement
Saturday, August 07, 2010
11:43 AM

CONTROL FLOW STATEMENT

1. IF- Statement:
It is the basic form where the if statement evaluate a test condition and direct program execution depending on the result of that evaluation.

Syntax:

If (Expression)
{
Statement 1;
Statement 2;
}

Where a statement may consist of a single statement, a compound statement or nothing as an empty statement. The Expression also referred so as test condition
must be enclosed in parenthesis, which cause the expression to be evaluated first, if it evaluate to true (a non zero value), then the statement associated with it
will be executed otherwise ignored and the control will pass to the next statement.
Example:

if (a>b)
{
printf (“a is larger than b”);
}

2. IF-ELSE Statement:
An if statement may also optionally contain a second statement, the ``else clause,'' which is to be executed if the condition is not met. Here is an example:

if(n > 0)
average = sum / n;
else
{
printf("can't compute average\n");
average = 0;
}

3. NESTED-IF- Statement:
It's also possible to nest one if statement inside another. (For that matter, it's in general possible to nest any kind of statement or control flow construct within
another.) For example, here is a little piece of code which decides roughly which quadrant of the compass you're walking into, based on an x value which is
positive if you're walking east, and a y value which is positive if you're walking north:

if(x > 0)
{
if(y > 0)
printf("Northeast.\n");
else printf("Southeast.\n");
}
else {
if(y > 0)
printf("Northwest.\n");
else printf("Southwest.\n");
}

/* Illustates nested if else and multiple arguments to the scanf function. */

#include <stdio.h>

main()
{
int invalid_operator = 0;
char operator;
float number1, number2, result;

printf("Enter two numbers and an operator in the format\n");

printf(" number1 operator number2\n");
scanf("%f %c %f", &number1, &operator, &number2);

if(operator == '*')
result = number1 * number2;
else if(operator == '/')
result = number1 / number2;
else if(operator == '+')
result = number1 + number2;

Pgramming in C Page 33
 result = number1 + number2;
else if(operator == '-')
result = number1 - number2;
else
invalid _ operator = 1;

if( invalid _ operator != 1 )

printf("%f %c %f is %f\n", number1, operator, number2, result );
else
printf("Invalid operator.\n");
}

Sample Program Output

Enter two numbers and an operator in the format
number1 operator number2
23.2 + 12
23.2 + 12 is 35.2

4. Switch Case

This is another form of the multi way decision. It is well structured, but can only be used in certain cases where;
 Only one variable is tested, all branches must depend on the value of that variable. The variable must be an integral type. (int, long, short or char).
 Each possible value of the variable can control a single branch. A final, catch all, default branch may optionally be used to trap all unspecified cases.
Hopefully an example will clarify things. This is a function which converts an integer into a vague description. It is useful where we are only concerned in
measuring a quantity when it is quite small.

estimate(number)
int number;
/* Estimate a number as none, one, two, several, many */
{
switch(number)
{
case 0 :
printf("None\n");
break;
case 1 :
printf("One\n");
break;
case 2 :
printf("Two\n");
break;
case 3 :
case 4 :
case 5 :
printf("Several\n");
break;
default :
printf("Many\n");
break;
}
}

Each interesting case is listed with a corresponding action. The break statement prevents any further statements from being executed by leaving the
switch. Since case 3 and case 4 have no following break, they continue on allowing the same action for several values of number.
Both if and switch constructs allow the programmer to make a selection from a number of possible actions.

Pgramming in C Page 34
 Loops
Saturday, August 07, 2010
11:44 AM

Loops
Looping is a way by which we can execute any some set of statements more than one times continuously .In c there are mainly three types of loops are use :

1. While Loop
Loops generally consist of two parts: one or more control expressions which (not surprisingly) control the execution of the loop, and the body, which is the
statement or set of statements which is executed over and over.
The general syntax of a while loop is

Initialization
while( expression )
{
Statement1
Statement2
Statement3

The most basic loop in C is the while loop. A while loop has one control expression, and executes as long as that expression is true. This example repeatedly
doubles the number 2 (2, 4, 8, 16, ...) and prints the resulting numbers as long as they are less than 1000:

int x = 2;
while(x < 1000)
{
printf("%d\n", x);
x = x * 2;
}

(Once again, we've used braces {} to enclose the group of statements which are to be executed together as the body of the loop.)

2. For Loop
Our second loop, which we've seen at least one example of already, is the for loop. The general syntax of a while loop is

for( Initialization;expression;Increments/decrements )
{
Statement1
Statement2
Statement3

The first one we saw was:

for (i = 0; i < 10; i = i + 1)
printf ("i is %d\n", i);
(Here we see that the for loop has three control expressions. As always, the statement can be a brace-enclosed block.)

3. Do while Loop
This is very similar to the while loop except that the test occurs at the end of the loop body. This guarantees that the loop is executed at least once before
continuing. Such a setup is frequently used where data is to be read. The test then verifies the data, and loops back to read again if it was unacceptable.

do
{
printf("Enter 1 for yes, 0 for no :");
scanf("%d", &input_value);
}
while (input_value != 1 && input_value != 0)

Pgramming in C Page 35
Break Statement
Saturday, August 07, 2010
11:45 AM

The break Statement

We have already met break in the discussion of the switch statement. It is used to exit from a loop or a switch, control passing to the first statement
beyond the loop or a switch.
With loops, break can be used to force an early exit from the loop, or to implement a loop with a test to exit in the middle of the loop body. A break within a
loop should always be protected within an if statement which provides the test to control the exit condition.

Pgramming in C Page 36
Continue Statement
Saturday, August 07, 2010
11:45 AM

The continue Statement

This is similar to break but is encountered less frequently. It only works within loops where its effect is to force an immediate jump to the loop control statement.
 In a while loop, jump to the test statement.
 In a do while loop, jump to the test statement.
 In a for loop, jump to the test, and perform the iteration.
Like a break, continue should be protected by an if statement. You are unlikely to use it very often.

Take the following example:

int i;
for (i=0;i<10;i++)
{

if (i==5)
continue;
printf("%d",i);
if (i==8)
break;
}

This code will print 1 to 8 except 5.

Continue means, whatever code that follows the continue statement WITHIN the loop code block will not be exectued and the program will go to the next
iteration, in this case, when the program reaches i=5 it checks the condition in the if statement and executes 'continue', everything after continue, which are the
printf statement, the next if statement, will not be executed.

Break statement will just stop execution of the look and go to the next statement after the loop if any. In this case when i=8 the program will jump out of the
loop. Meaning, it wont continue till i=9, 10.

Comment:
o The compiler is "line oriented", and parses your program in a line-by- line fashion.
o There are two kinds of comments: single- line and multi- line comments.
o The single- line comment is indicated by "//"
This means everything after the first occurrence of "//", UP TO THE END OF CURRENT LINE, is ignored.
o The multi-line comment is indicated by the pair "/*" and "*/".
This means that everything between these two sequences will be ignored. This may ignore any number of lines.
Here is a variant of our first program:

/* This is a variant of my first program.

* It is not much, I admit.

*/

int main() {

printf("Hello World!\n"); // that is all?

return(0);

Pgramming in C Page 37
Function
Saturday, August 07, 2010
11:45 AM

Function

A function is a ``black box'' that we've locked part of our program into. The idea behind a function is that it compartmentalizes part of the program, and
in particular, that the code within the function has some useful properties:

1. It performs some well-defined task, which will be useful to other parts of the program.
2. It might be useful to other programs as well; that is, we might be able to reuse it (and without having to rewrite it).
3. The rest of the program doesn't have to know the details of how the function is implemented. This can make the rest of the program easier to think about.
4. The function performs its task well. It may be written to do a little more than is required by the first program that calls it, with the anticipation that the
calling program (or some other program) may later need the extra functionality or improved performance. (It's important that a finished function do its job
well, otherwise there might be a reluctance to call it, and it therefore might not achieve the goal of reusability.)
5. By placing the code to perform the useful task into a function, and simply calling the function in the other parts of the program where the task must be
performed, the rest of the program becomes clearer: rather than having some large, complicated, difficult-to-understand piece of code repeated wherever the
task is being performed, we have a single simple function call, and the name of the function reminds us which task is being performed.
6. Since the rest of the program doesn't have to know the details of how the function is implemented, the rest of the program doesn't care if the function is
reimplemented later, in some different way (as long as it continues to perform its same task, of course!). This means that one part of the program can be
rewritten, to improve performance or add a new feature (or simply to fix a bug), without having to rewrite the rest of the program.

Functions are probably the most important weapon in our battle against software complexity. You'll want to learn when it's appropriate to break processing out
into functions (and also when it's not), and how to set up function interfaces to best achieve the qualities mentioned above: reusability, information hiding,
clarity, and maintainability.
So what defines a function? It has a name that you call it by, and a list of zero or more arguments or parameters that you hand to it for it to act on or to direct its
work; it has a body containing the actual instructions (statements) for carrying out the task the function is supposed to perform; and it may give you back a return
value, of a particular type.
Here is a very simple function, which accepts one argument, multiplies it by 2, and hands that value back:

int multbytwo(int x)
{
int retval;
retval = x * 2;
return retval;
}

On the first line we see the return type of the function (int), the name of the function (multbytwo), and a list of the function's arguments, enclosed in
parentheses. Each argument has both a name and a type; multbytwo accepts one argument, of type int, named x. The name x is arbitrary, and is used only
within the definition of multbytwo. The caller of this function only needs to know that a single argument of type int is expected; the caller does not need to
know what name the function will use internally to refer to that argument. (In particular, the caller does not have to pass the value of a variable named x.)
Next we see, surrounded by the familiar braces, the body of the function itself. This function consists of one declaration (of a local variable retval) and two
statements. The first statement is a conventional expression statement, which computes and assigns a value to retval, and the second statement is a return
statement, which causes the function to return to its caller, and also specifies the value which the function returns to its caller.

The return statement can return the value of any expression, so we don't really need the local retval variable; the function could be collapsed to-

int multbytwo(int x)
{
return x * 2;
}

How do we call a function? We've been doing so informally since day one, but now we have a chance to call one that we've written, in full detail. Here is a
tiny skeletal program to call multby2:

#include <stdio.h>

extern int multbytwo(int);

int main()
{
int i, j;
i = 3;
j = multbytwo(i);
printf("%d\n", j);
return 0;
}

This looks much like our other test programs, with the exception of the new line
extern int multbytwo(int);

This is an external function prototype declaration. It is an external declaration, in that it declares something which is defined somewhere else. (We've already
seen the defining instance of the function multbytwo, but maybe the compiler hasn't seen it yet.) The function prototype declaration contains the three pieces of
information about the function that a caller needs to know: the function's name, return type, and argument type(s). Since we don't care what name the multbytwo
function will use to refer to its first argument, we don't need to mention it. (On the other hand, if a function takes several arguments, giving them names in the

Pgramming in C Page 38
function will use to refer to its first argument, we don't need to mention it. (On the other hand, if a function takes several arguments, giving them names in the
prototype may make it easier to remember which is which, so names may optionally be used in function prototype declarations.) Finally, to remind us that this is
an external declaration and not a defining instance, the prototype is preceded by the keyword extern.
The presence of the function prototype declaration lets the compiler know that we intend to call this function, multbytwo. The information in the prototype lets
the compiler generate the correct code for calling the function, and also enables the compiler to check up on our code (by making sure, for example, that we pass
the correct number of arguments to each function we call).

Down in the body of main, the action of the function call should be obvious: the line
j = multbytwo(i);
calls multbytwo, passing it the value of i as its argument. When multbytwo returns, the return value is assigned to the variable j. (Notice that the value of main's
local variable i will become the value of multbytwo's parameter x; this is absolutely not a problem, and is a normal sort of affair.)

This example is written out in ``longhand,'' to make each step equivalent. The variable i isn't really needed, since we could just as well call
j = multbytwo(3);
And the variable j isn't really needed, either, since we could just as well call
printf("%d\n", multbytwo(3));

Here, the call to multbytwo is a sub expression which serves as the second argument to printf. The value returned by multbytwo is passed immediately to
printf. (Here, as in general, we see the flexibility and generality of expressions in C. An argument passed to a function may be an arbitrarily complex sub
expression, and a function call is itself an expression which may be embedded as a sub expression within arbitrarily complicated surrounding expressions.)
We should say a little more about the mechanism by which an argument is passed down from a caller into a function. Formally, C is call by value, which means
that a function receives copies of the values of its arguments. We can illustrate this with an example. Suppose, in our implementation of multbytwo, we had
gotten rid of the unnecessary retval variable like this:

int multbytwo(int x)
{
x = x * 2;
return x;
}

Recursive Functions
A recursive function is one which calls itself. This is another complicated idea which you are unlikely to meet frequently. We shall provide some examples
to illustrate recursive functions.

Recursive functions are useful in evaluating certain types of mathematical function. You may also encounter certain dynamic data structures such as linked lists
or binary trees. Recursion is a very useful way of creating and accessing these structures.
Here is a recursive version of the Fibonacci function. We saw a non recursive version of this earlier.

int fib(int num)

/* Fibonacci value of a number */
{
switch(num)
{
case 0:
return(0);
break;
case 1:
return(1);
break;
default: /* Including recursive calls */
return(fib(num - 1) + fib(num - 2));
break;
}
}

We met another function earlier called power. Here is an alternative recursive version.

double power(double val, unsigned pow)

{
if(pow == 0) /* pow(x, 0) returns 1 */
return(1.0);
else
return(power(val, pow - 1) * val);
}

Notice that each of these definitions incorporate a test. Where an input value gives a trivial result, it is returned directly; otherwise the function calls itself,
passing a changed version of the input values. Care must be taken to define functions which will not call themselves indefinitely, otherwise your program will
never finish.
The definition of fib is interesting, because it calls itself twice when recursion is used. Consider the effect on program performance of such a function
calculating the Fibonacci function of a moderate size number.

Pgramming in C Page 39
If such a function is to be called many times, it is likely to have an adverse effect on program performance.
Don't be frightened by the apparent complexity of recursion. Recursive functions are sometimes the simplest answer to a calculation. However there is always an
alternative non-recursive solution available too. This will normally involve the use of a loop, and may lack the elegance of the recursive solution.

Pgramming in C Page 40
 Array And String
Saturday, August 07, 2010
11:48 AM

ARRAY AND STRING

• Array
Arrays are widely used data type in „C‟ language. It is a collection of elements of similar data type. These similar elements could be of all integers, all
floats or all characters. An array of character is called as string whereas and array of integer or float is simply called as an array. So array may be defined as a
group of elements that share a common name and that are defined by position or index. The elements of an arrays are store in sequential order in memory.
There are mainly two types of Arrays are used:

○ One dimensional Array

So far, we've been declaring simple variables: the declaration
int i;
declares a single variable, named i, of type int. It is also possible to declare an array of several elements. The declaration
int a[10];
declares an array, named a, consisting of ten elements, each of type int. Simply speaking, an array is a variable that can hold more than one value.
You specify which of the several values you're referring to at any given time by using a numeric subscript. (Arrays in progra mming are similar to
vectors or matrices in mathematics.) We can represent the array a above with a picture like this:

In C, arrays are zero-based: the ten elements of a 10-element array are numbered from 0 to 9. The subscript which specifies a single element of an
array is simply an integer expression in square brackets. The first element of the array is a[0], the second element is a[1], etc. You can use these
``array subscript expressions'' anywhere you can use the name of a simple variable, for example:
a[0] = 10;
a[1] = 20;
a[2] = a[0] + a[1];
Notice that the subscripted array references (i.e. expressions such as a[0] and a[1]) can appear on either side of the assignment operator. it is
possible to initialize some or all elements of an array when the array is defined. The syntax looks like this:
int a[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
The list of values, enclosed in braces {}, separated by commas, provides the initial values for successive elements of the ar ray.

The subscript does not have to be a constant like 0 or 1; it can be any integral expression. For example, it's common to loop over all elements of an
array:
int i;

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

a[i] = 0;
This loop sets all ten elements of the array a to 0.
Arrays are a real convenience for many problems, but there is not a lot that C will do with them for you automatically. In pa rticular, you can neither
set all elements of an array at once nor assign one array to another; both of the assignments
a = 0; /* WRONG */
and
int b[10];
b = a; /* WRONG */
are illegal.
To set all of the elements of an array to some value, you must do so one by one, as in the loop example above. To copy the co ntents of one array to
another, you must again do so one by one:
int b[10];

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

b[i] = a[i];
Remember that for an array declared
int a[10];
there is no element a[10]; the topmost element is a[9]. This is one reason that zero-based loops are also common in C. Note that the for loop
for(i = 0; i < 10; i = i + 1)
...
does just what you want in this case: it starts at 0, the number 10 suggests (correctly) that it goes through 10 iterations, but the less-than comparison
means that the last trip through the loop has i set to 9. (The comparison i <= 9 would also work, but it would be less clear and therefore poorer
style.)

○ Multidimensional Array
The declaration of an array of arrays looks like this:
int a2[5][7];
You have to read complicated declarations like these ``inside out.'' What this one says is that a2 is an array of 5 something‟s, and that each of the
something‟s is an array of 7 ints. More briefly, ``a2 is an array of 5 arrays of 7 ints,'' or, ``a2 is an array of array of int.'' In the declaration of a2,
the brackets closest to the identifier a2 tell you what a2 first and foremost is. That's how you know it's an array of 5 arrays of size 7, not the other way
around. You can think of a2 as having 5 ``rows'' and 7 ``columns,'' although this interpretation is not mandatory. (You could also treat the ``first'' or
inner subscript as ``x'' and the second as ``y.'' Unless you're doing something fancy, all you have to worry about is that the subscripts when you access
the array match those that you used when you declared it, as in the examples below.)
To illustrate the use of multidimensional arrays, we might fill in the elements of the above array a2 using this piece of code:
int i, j;
for(i = 0; i < 5; i = i + 1)
{
for(j = 0; j < 7; j = j + 1)

a2[i][j] = 10 * i + j;
}
This pair of nested loops sets a[1][2] to 12, a[4][1] to 41, etc. Since the first dimension of a2 is 5, the first subscripting index variable, i, runs from
0 to 4. Similarly, the second subscript varies from 0 to 6.
We could print a2 out (in a two-dimensional way, suggesting its structure) with a similar pair of nested loops:
for (i = 0; i < 5; i = i + 1)

Pgramming in C Page 41
 for (i = 0; i < 5; i = i + 1)
{
for (j = 0; j < 7; j = j + 1)
printf ("%d\t", a2[i][j]);
printf ("\n");
}
(The character \t in the printf string is the tab character.)
Just to see more clearly what's going on, we could make the ``row'' and ``column'' subscripts explicit by printing them, too:
for(j = 0; j < 7; j = j + 1)
printf("\t%d:", j);
printf ("\n");

for(i = 0; i < 5; i = i + 1)
{
printf("%d:", i);
for(j = 0; j < 7; j = j + 1)
printf("\t%d", a2[i][j]);
printf("\n"); }
This last fragment would print
0: 1: 2: 3: 4: 5: 6:
0: 0 1 2 3 4 5 6
1: 10 11 12 13 14 15 16
2: 20 21 22 23 24 25 26
3: 30 31 32 33 34 35 36
4: 40 41 42 43 44 45 46

• STRING
String are the combination of number of characters these are used to store any word in any variable of constant. A string is an array of character. It is
internally represented in system by using ASCII value. Every single character can have its own ASCII value in the system. A character string is stored in
one array of character type.
e.g. “Ram” contains ASCII value per location, when we are using strings and then these strings are always terminated by character „\0‟. We use conversion
specifies %s to set any string we can have any string as follows:-
char nm [25].
When we store any value in nm variable then it can hold only 24 character because at the end of the string one character is consumed automatically by „\0‟.
#include<string.h>
There are some common inbuilt functions to manipulation on string in string.h file. these are as follows:
1. strlen - string length
2. strcpy - string copy
3. strcmp - string compare
4. strups - string upper
5. strlwr - string lower
6. strcat - string concatenate

Pgramming in C Page 42
Structures
Saturday, August 07, 2010
12:18 PM

STRUCTURES
Introduction to Structure
 Structure is a method of packing the data of different types.
 When we require using a collection of different data items of different data types in that situation we can use a structure.
 A structure is used as a method of handling a group of related data items of different data types.

A structure is a collection of variables under a single name. These variables can be of different types, and each has a name which is used to select it from
the structure. A structure is a convenient way of grouping several pieces of related information together.
A structure can be defined as a new named type, thus extending the number of available types. It can use other structures, arrays or pointers as some of its
members, though this can get complicated unless you are careful.

Defining a Structure
A structure type is usually defined near to the start of a file using a typedef statement. typedef defines and names a new type, allowing its use
throughout the program. typedefs usually occur just after the #define and #include statements in a file.
Here is an example structure definition.

typedef struct
{
char name[64];
char course[128];
int age;
int year;
}
student;

This defines a new type student variables of type student can be declared as follows.

student st_rec;

Notice how similar this is to declaring an int or float.

The variable name is st_rec, it has members called name, course, age and year.

Accessing Members of a Structure

Each member of a structure can be used just like a normal variable, but its name will be a bit longer. To return to the examples above, member name of
structure st_rec will behave just like a normal array of char, however we refer to it by the name .

st_rec.name

Here the dot is an operator which selects a member from a structure.

Where we have a pointer to a structure we could dereference the pointer and then use dot as a member selector. This method is a little clumsy to type. Since
selecting a member from a structure pointer happens frequently, it has its own operator -> which acts as follows. Assume that st_ptr is a pointer to a
structure of type student We would refer to the name member as.

st_ptr -> name

/* 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);

Pgramming in C Page 43
 printf(“students combination=%s\n”,newstudent.combination);
printf(“Age of student=%d\n”,newstudent.age);
}

Arrays of structure:
It is possible to define a array of structures for example if we are maintaining information of all the students in the college and if 100 students are studying
in the college. We need to use an array than single variables. We can define an array of structures as shown in the following example:

structure information
{
int id_no;
char name[20];
char address[20];
char combination[3];
int age;
}
student[100];

An array of structures can be assigned initial values just as any other array can. Remember that each element is a structure that must be assigned
corresponding initial values as illustrated below.

#include< stdio.h >

{
struct info
{
int id_no;
char name[20];
char address[20];
char combination[3];
int age;
}
struct info std[100];
int I,n;
printf(“Enter the number of students”);
scanf(“%d”,&n);
printf(“ Enter Id_no,name address combination age\m”);
for(I=0;I < n;I++)
scanf(“%d%s%s%s%d”,&std[I].id_no,std[I].name,std[I].address,std[I].combination,&std[I].age);
printf(“\n Student information”);
for (I=0;I< n;I++)
printf(“%d%s%s%s%d\n”, ”,std[I].id_no,std[I].name,std[I].address,std[I].combination,std[I].age);
}

Structure within a structure:

A structure may be defined as a member of another structure. In such structures the declaration of the embedded structure must appear before the
declarations of other structures.

struct date
{
int day;
int month;
int year;
};
struct student
{
int id_no;
char name[20];
char address[20];
char combination[3];
int age;
structure date def;
structure date doa;
}
oldstudent, newstudent;

the sturucture student constains another structure date as its one of its members.

Pgramming in C Page 44
Union
Saturday, August 07, 2010
12:18 PM

UNIONS
Unions like structure contain members whose individual data types may differ from one another. However the members that 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 application involving multiple members. Where values need not be assigned to all the members at any one time.
Like structures union can be declared using the keyword union as follows:

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

this declares a variable code of type union item. The union contains three members each with a different data type. However we can use only one of them at
a time. This is because if only one location is allocated for union variable irrespective of size. The compiler allocates a piece of storage that is large enough
to access a union member we can use the same syntax that we use to access structure members. That is

code.m
code.p
code.c

are all valid member variables. During accessing we should make sure that we are accessing the member whose value is currently stored.
For example a statement such as -

code.m=456;
code.p=456.78;
printf(“%d”,code.m);
Would prodece erroneous result.

Pgramming in C Page 45
Pointer
Saturday, August 07, 2010
12:18 PM

Pointer
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 which 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 declaration 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=&ptr;
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;

Pgramming in C Page 46
 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.
1. Call by reference
2. 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 so on 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 cal l by value. The
corresponding formal parameter always represents a local variable in the called function. The current value of the correspond ing actual
parameter becomes the initial value of formal parameter. In the body of the actual parameter, the value of formal parameter m ay be changed. In
the body of the subprogram, the value of formal parameter may be changed by assignment or input statements. This will not cha nge 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 o f 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 v alue 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()
{

Pgramming in C Page 47
 {
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 zeros 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;

Pgramming in C Page 48
ASCII Text Files
Saturday, August 07, 2010
12:55 PM

ASCII Text files

A text file can be a stream of characters that a computer can process sequentially. It is not only processed sequentially but only in forward direction. For this
reason a text file is usually opened for only one kind of operation (reading, writing, or appending) at any given time.
Similarly, since text files only process characters, they can only read or write data one character at a time. (In C Programming Language, Functions are
provided that deal with lines of text, but these still essentially process data one character at a time.) A text stream in C is a special kind of file. Depending on
the requirements of the operating system, newline characters may be converted to or from carriage-return/linefeed combinations depending on whether data is
being written to, or read from, the file. Other character conversions may also occur to satisfy the storage requirements of the operating system. These
translations occur transparently and they occur because the programmer has signalled the intention to process a text file.

What is a File?
Abstractly, a file is a collection of bytes stored on a secondary storage device, which is generally a disk of some kind. The collection of bytes may be
interpreted, for example, as characters, words, lines, paragraphs and pages from a textual document; fields and records belonging to a database; or pixels from
a graphical image. The meaning attached to a particular file is determined entirely by the data structures and operations used by a program to process the file. It
is conceivable (and it sometimes happens) that a graphics file will be read and displayed by a program designed to process textual data. The result is that no
meaningful output occurs (probably) and this is to be expected. A file is simply a machine decipherable storage media where programs and data are stored for
machine usage.
Essentially there are two kinds of files that programmers deal with text files and binary files. These two classes of files will be discussed in the following
sections.

Binary files
A binary file is no different to a text file. It is a collection of bytes. In C Programming Language a byte and a character are equivalent. Hence a binary file is
also referred to as a character stream, but there are two essential differences.
i. No special processing of the data occurs and each byte of data is transferred to or from the disk unprocessed.
ii. C Programming Language places no constructs on the file, and it may be read from, or written to, in any manner chosen by the programmer.
Binary files can be either processed sequentially or, depending on the needs of the application, they can be processed using random access techniques. In C
Programming Language, processing a file using random access techniques involves moving the current file position to an appropriate place in the file before
reading or writing data. This indicates a second characteristic of binary files
– they a generally processed using read and write operations simultaneously.
For example, a database file will be created and processed as a binary file. A record update operation will involve locating the appropriate record, reading the
record into memory, modifying it in some way, and finally writing the record back to disk at its appropriate location in the file. These kinds of operations are
common to many binary files, but are rarely found in applications that process text files.

Creating a file and output some data

In order to create files we have to learn about File I/O i.e. how to write data into a file and how to read data from a file. We will start this section with an
example of writing data to a file. We begin as before with the include statement for stdio.h, then define some variables for use in the example including a rather
strange looking new type.

/* Program to create a file and write some data the file */

#include <stdio.h>
#include <stdio.h>
main( )
{
FILE *fp;
char stuff[25];
int index;
fp = fopen("TENLINES.TXT","w"); /* open for writing */
strcpy(stuff,"This is an example line.");
for (index = 1; index <= 10; index++)
fprintf(fp,"%s Line number %d\n", stuff, index);
fclose(fp); /* close the file before ending program */
}

The type FILE is used for a file variable and is defined in the stdio.h file. It is used to define a file pointer for use in file operations. Before we can write to a
file, we must open it. What this really means is that we must tell the system that we want to write to a file and what the file name is. We do this with the
fopen() function illustrated in the first line of the program. The file pointer, fp in our case, points to the file and two arguments are required in the parentheses,
the file name first, followed by the file type.

The file name is any valid DOS file name, and can be expressed in upper or lower case letters, or even mixed if you so desire. It is enclosed in double quotes.
For this example we have chosen the name TENLINES.TXT. This file should not exist on your disk at this time. If you have a file with this name, you should
change its name or move it because when we execute this program, its contents will be erased. If you have a file by this name, that is good because we will
create one and put some data into it. You are permitted to include a directory with the file name. The directory must, of course, be a valid directory otherwise
an error will occur. Also, because of the way C handles literal strings, the directory separation character must be written twice. For example, if the file is to be
stored in the \PROJECTS sub directory then the file name should be entered as “\\PROJECTS\\TENLINES.TXT”. The second parameter is the file attribute
and can be any of three letters, r, w, or a, and must be lower case.

Reading (r)
When an r is used, the file is opened for reading, a w is used to indicate a file to be used for writing, and an indicates that you desire to append additional data
to the data already in an existing file. Most C compilers have other file attributes available; check your Reference Manual for details. Using the r indicates that
the file is assumed to be a text file. Opening a file for reading requires that the file already exist. If it does not exist, the file pointer will be set to NULL and
can be checked by the program.
Here is a small program that reads a file and display its contents on screen. /* Program to display the contents of a file on screen */

#include <stdio.h>
void main()
{
FILE *fp;
int c;
fp = fopen("prog.c","r");

Pgramming in C Page 49
 fp = fopen("prog.c","r");
c = getc(fp) ;
while (c!= EOF)
{
putchar(c);
c = getc(fp);
}
fclose(fp);
}

Writing (w)
When a file is opened for writing, it will be created if it does not already exist and it will be reset if it does, resulting in the deletion of any data already there.
Using the w indicates that the file is assumed to be a text file.
Here is the program to create a file and write some data into the file.

#include <stdio.h>
int main()
{
FILE *fp;
file = fopen("file.txt","w");
/*Create a file and add text*/
fprintf(fp,"%s","This is just an example :)"); /*writes data to the file*/
fclose(fp); /*done!*/
return 0;
}

Appending (a):
When a file is opened for appending, it will be created if it does not already exist and it will be initially empty. If it does exist, the data input point will be
positioned at the end of the present data so that any new data will be added to any data that already exists in the file. Using the a indicates that the file is
assumed to be a text file.
Here is a program that will add text to a file which already exists and there is some text in the file.

#include <stdio.h>
int main()
{
FILE *fp
file = fopen("file.txt","a");
fprintf(fp,"%s","This is just an example :)"); /*append some text*/
fclose(fp);
return 0;
}

Outputting to the file

The job of actually outputting to the file is nearly identical to the outputting we have already done to the standard output device. The only real differences
are the new function names and the addition of the file pointer as one of the function arguments. In the example program, fprintf replaces our familiar
printf function name, and the file pointer defined earlier is the first argument within the parentheses. The remainder of the statement looks like, and in
fact is identical to, the printf statement.

Closing a file
To close a file you simply use the function fclose with the file pointer in the parentheses. Actually, in this simple program, it is not necessary to close the
file because the system will close all open files before returning to DOS, but it is good programming practice for you to close all files in spite of the fact
that they will be closed automatically, because that would act as a reminder to you of what files are open at the end of eachprogram.
You can open a file for writing, close it, and reopen it for reading, then close it, and open it again for appending, etc. Each time you open it, you could
use the same file pointer, or you could use a different one. The file pointer is simply a tool that you use to point to a file and you decide what file it will
point to. Compile and run this program. When you run it, you will not get any output to the monitor because it doesn’t generate any. After running it,
look at your directory for a file named TENLINES.TXT and type it; that is where your output will be. Compare the output with that specified in the
program; they should agree! Do not erase the file named TENLINES.TXT yet; we will use it in
some of the other examples in this section.

Reading from a text file

Now for our first program that reads from a file. This program begins with the familiar include, some data definitions, and the file opening statement which
should require no explanation except for the fact that an r is used here because we want to read it.

#include <stdio.h>
main( )
{
FILE *fp;
char c;
funny = fopen("TENLINES.TXT", "r");
if (fp == NULL)
printf("File doesn't exist\n");
else
{
do
{
c = getc(fp); /* get one character from the file
*/
putchar(c); /* display it on the monitor
*/
}
while (c != EOF); /* repeat until EOF (end of file)
*/
}
fclose(fp);

Pgramming in C Page 50
 }

In this program we check to see that the file exists, and if it does, we execute the main body of the program. If it doesn‟t, we print a message and quit. If the
file does not exist, the system will set the pointer equal to NULL which we can test. The main body of the program is one do while loop in which a single
character is read from the file and output to the monitor until an EOF (end of file) is detected from the input file. The file is then closed and the program is
terminated. At this point, we have the potential for one of the most common and most perplexing problems of programming in C.The variable returned from
the getc function is a character, so we can use a char variable for this purpose. There is a problem that could develop here if we happened to use an unsigned
char however, because C usually returns a minus one for an EOF - which an unsigned char type variable is not
capable of containing. An unsigned char type variable can only have the values of zero to 255, so it will return a 255 for a minus one in C. This is a very
frustrating problem to try to find. The program can never find the EOF and will therefore never terminate the loop. This is easy to prevent: always have a char
or int type variable for use in returning an EOF. There is another problem with this program but we will worry about it when we get to the next program and
solve it with the one following that.
After you compile and run this program and are satisfied with the results, it would be a good exercise to change the name of TENLINES.TXT and run the
program again to see that the NULL test actually works as stated. Be sure to change the name back because we are still not finished with TENLINES.TXT.

BUBBLE SORT
In the bubble sort, as elements are sorted they gradually "bubble" (or rise) to their proper location in the array, like bubbles rising in a glass of soda. The
bubble sort repeatedly compares adjacent elements of an array. The first and second elements are compared and swapped if out of order. Then the second
and third elements are compared and swapped if out of order. This sorting process continues until the last two elements of the array are compared and
swapped if out of order.

Array at beginning: 84 69 76 86 94 91
After Pass #1: 84 76 86 94 91 69
After Pass #2: 84 86 94 91 76 69
After Pass #3: 86 94 91 84 76 69
After Pass #4: 94 91 86 84 76 69
After Pass #5 (done): 94 91 86 84 76 69
The bubble sort is an easy algorithm to program, but it is slower than many other sorts. With a bubble sort, it is always necessary to make one final "pass"
through the array to check to see that no swaps are made to ensure that the process is finished. In actuality,the process is finished before this last pass is made.

// Bubble Sort Function for ASCENDING Order

void BubbleSort(apvector <int> &num)

{
int i, j, flag = 1; // set flag to 1 to start first pass
int temp; // holding variable
int numLength = num.length( );
for(i = 1; (i <= numLength) && flag; i++)
{
flag = 0;
for (j=0; j < (numLength -1); j++)
{
if (num[j] > num[j+1]) // desscending order simply changes to <
{
temp = num[j]; // swap elements
num[j] = num[j+1];
num[j+1] = temp;
flag = 1; // indicates that a swap occurred.
}
}
}
return
}

BINARY SEARCH

int binarysearch(int x[10],int n)

{
int i,j,beg=0,end=9,mid;
mid=(beg+end)/2;
while(x[mid]!=n &&beg<end)
{
if(x[mid]<n)
beg=mid+1;
else
end=mid-1;
mid=(beg+end)/2;
}
return(mid);
}

Pgramming in C Page 51
Keywords
Monday, August 09, 2010
9:13 PM

1. Algorithm
An ordered list of finite steps that enable one to obtain a solution to a given problem.

2. Bottom-up Approach
A problem-solving approach in which smaller sub-tasks are continuously combined to form the complete solution.

3. Flow Chart
Visual representation of an algorithm using standard graphical symbols.

4. Input
Any data and/or information that is consumed in an exercise of problem solving is called Input.

5. Modular Programming
Programming practice in which related processes are grouped to form Modules.

6. Output
The result of the processing of the input.

7. Problem Definition
It is a clear and unambiguous statement of the problem agreed upon mutually both by the user and the analyst.

8. Procedural Programming
Programming that views a solution in terms of processes that transform that input into output.

9. Processing
The set of actions that work upon the input to generate the required output.

10. Program
It is an Algorithm written an some computer programming language so that a computer may solve that problem
intended.

11. Programming
The act of writing computer programs.

12. Programming Paradigm

The philosophy of developing a computer program.

13. Structured Programming

Programming practice that follows a structured approach.

14. Top-down Approach

A Problem solving approach in which a task is continuously broken into sets of simpler sub-tasks until all the sub-tasks
can be programmed easily.

Keywords
Pgramming in C Page 52
15. Keywords
Sentence can contain certain words which are used for specific purposes. These words are called keywords. e.g. to
show a message the keyword is 'display'.

16. main()
main() is a driver function used by the C system to tell the computer where the program stats.

17. Character set

Character set is a set of characters which are submitted to the compiler and interpreted in various contents as
characters, names/identifier, constants and statements.

18. Assignment operator

An executable operation (represented by = ) that stores a valid value into a variable.

19. Constant
A named data item whose value does not change throughout the execution of the program.

20. Identifier
A string of characters representing the name to identify a variable, function etc.

21. While space

The characters that separate one identifier from the other like space, tab, carriage return, new line etc.

22. Variable
A named location in the memory that can store a value of specified type.

23. The size of operator

The size of operator which is used to measure the date sizes. It a unary compile type operator that is to return the
length of the variable or parenthesized type specifies.

24. Expression
A combination of identifiers and operators according to some rule that yields a value.

25. Operator
A symbol that works on one or more values to yield another value.

26. Type casting

Specifying the data type before a value in order to convert one data type to another compatible data type.

27. Statement
A statement is a section of code which directs the computer to carry out some task.

28. Function
A named unit of statements that accepts specified number of values and returns a single computed value to the caller.

29. Token
A token is a group of characters separated from other group of characters by one or more white space.

30. Operator proceeding

The precedents of an operator determine the order in which expression will be evaluated.

31. ASCII
(American standard code for information interchange) a coding scheme that assigns an integer between 0 to 255 to
every character on the keyword.

32. Console
The keyword and monitor interface through which an operator usually interacts with rest of the computer resources.

Pgramming in C Page 53
 The keyword and monitor interface through which an operator usually interacts with rest of the computer resources.

33. Eof
A constant defined in the language C to indicate the end of the file or end of the input.

34. Header files

A text file that contains prototype of functions, definitions of constants etc. and which can be included in a C program
file to access those function and constants.

35. #include compiler directive

This compiler directive instructs the complier to insert the contents of the specified file in place of this line.

36. Standard library

A group of in-built functions stored in a single file as a unit.

37. Break statement

A statement that terminates the block of statements currently under execution.

38. Conditional operator

An operator that takes three arguments in which the first one is conditional statement. One of the two next statements is
executed depending on the truth value of the conditional statement just like if-else statement.

39. Conditional statement

A statement that evaluates to either true or false.

40. Continue statement

The statement that ignores execution of further statements and forces the loop to evaluate the loop condition once
again.

41. Default statement

An optional statement in a switch that is executed if none of the conditions evaluates to true.

42. Switch statement

A multi - selection statement that branches to that statement whose specified condition evaluates to true.

43. Do-while loop

A looping statement that executes the enclosed block of statements as long as the condition remains true. It is executed
at least once.

44. Goto statement

A jump statement that takes the execution of statement pointer to a location in the program specified by a label.

45. Nested loop

A loop containing another loop inside.

46. Return statement

The statement that returns the execution control to the caller with the computed value.

47. While loop

A looping statement that executes the enclosed block of statements as long as the condition remains true. It may not
execute even once if the condition is found false in the beginning itself.

48. Array
A user defined simple data structure which represents a group of same type of variables having same name each being
referred to by an integral index.

49. Subscript
The integral index by which an array element is accessed.

Index
Pgramming in C Page 54
50. Index
Same as subscript

51. One dimensional array

An array in which elements are accessed using a single index.

52. Two dimensional array

An array in which elements are accessed using two indices.

53. Multi dimensional array

An array in which elements are accessed using multiple indices.

54. String
An array of characters terminated by the null character.

55. gets()
A C library function used to read a character entered at the keyboard and to place. It at the address pointed to by its
character pointer argument.

56. puts()
A C library function that writes its string argument to the screen followed by the new line.

57. string.h
A C header file that contains string manipulating library functions.

58. strcat()
The C library function that appends one string to another returning a pointer to concatenated string.

59. strcmp()
The C library function that compares two strings.

60. strcpy()
The C library function that copies one string to another.

61. strlen()
The C library function that returns the length of a string.

62. strncmp()
The C library function that compares portions of two strings.

63. Formal argument list

The optional variable list specified in the function definition.

64. Return
The C statement that is used to terminate a function by passing the returned value to the caller.

65. Automatic variable

A variable that is created when a function executes and remains alive as long as the function executes.

66. External variable

A variable that is declared outside the function in some other source file.

67. Static variable

A variable that is once created remains alive throughout the life of the program execution.

68. Register variable

A variable that is created in the C.P.U register to enhance the processing speed.

Pgramming in C Page 55
 A variable that is created in the C.P.U register to enhance the processing speed.

69. Call by value

a. A function call in which the caller arguments are copied into the formal arguments of the function.
b. A function call in which the value of the argument are passed.

70. Call by reference

a. A function call in which pointers to the arguments rather than the values are passed.
b. A function call in which the pointers to the arguments rather than the values are passed by the caller.

71. Recursion
A function calling itself repeatedly until a terminating criterion is met.

72. Structure
A grouped data type created by user.

73. Union
A data type that allows more than one variable to share the same memory area.

74. Enumeration
A data type that allows values to be treated by their cardinal number.

75. Pointer
A data type that stores address of a variable.

76. Dynamic memory allocation

A mechanism through which memory is allocated variables at runtime rather than at compile time.

Pgramming in C Page 56