C++ is an object-oriented programming language. It was developed by B.Jarne Strousstrup at AT&T Bell laboratories in Murray Hill, New Jersey, USA, in the early 1980’s. Strousstrup, an admirer of Simula67 and a strong supporter of C, wanted to combine the best of both the languages and create a more powerful language that could support object-oriented programming features and still retain the power and elegance of C. The result was C++, therefore, C++ is an extension of C with a major addition of the class construct feature of Simula67. Since the class was a major addition to the original C language, Strousstrup initially called the new language ‘C with classes’. However, later in 1983, the name was changed to C++. The idea of C++ comes from the increment operator ++, thereby suggesting that C++ is an augmented (incremented) version 0f C.
Comments: C++ introduces a new comment symbol // (double slash). Comments start with a double slash symbol and terminate at the end of the line. A comment may start anywhere in the line, and whatever follows till the end of the line is ignored. Note that is no closing symbol.
Output Operator: The identifier cout (pronounced as ‘C out’) is a predefined object that represents the standard output stream in C++. Here, the standard output stream represents the screen. It is also possible to redirect the output to other output devices.
The operator <<>> is known as extraction or get from operator. It extracts (or takes) the value from the keyboard and assigns it to the variable on its right.












A Look at Procedure – Oriented Programming: Conventional programming, using high level languages such as COBOL, FORTRAN and C, is commonly known as procedure - oriented programming (POP). In the procedure-oriented approach, the problem is viewed as a sequence of things to be done such as reading, calculating and printing. A number of functions are written to accomplish these tasks. The primary focus is on functions.
Some characteristics by procedure-oriented programming are:
Emphasis is on doing things (algorithms).
Large programs are divided into smaller programs known as functions.
Most of the functions share global data.
Data move openly around the system from function to function.
Function transforms data from one form to another.
Employs top-down approach in program design.

Object-Oriented Programming Paradigm:
Some of the striking features of object-oriented programming are:
Emphasis is on data rather than procedure.
Programs are divided into what are known as objects.
Data structures are designed such that they characterize the objects.
Functions that operate on the data of an object are tied together in the data structure.
Data is hidden and cannot be accessed by external functions.
Objects may communicate with each other through functions.
New data and functions can be easily added whenever necessary.
Follow bottom-up approach in program design.

Organization of data functions in OOP:
Basic Concepts of Object-Oriented Programming:
Objects
Classes
Data Abstractions and encapsulation
Inheritance
Polymorphism
Dynamic Binding
Message Passing
OBJECTS: Objects are the basic run-time entities in an object-oriented system. They may represent a person, a place, a bank account, a table of data or any item that the program has to handle. They may also represent user-defined data such as vectors, time and lists. Programming problem is analyzed in terms of objects and the nature of communication between them. Program objects should be chosen such that they match closely with the real-world objects. Objects take up space in the memory and have an associated address like a record in Pascal or a structure in C.
Two Ways of representing an object
Classes: The entire set of data and code of an object can be made a user-defined data type with the help of a class. In fact, objects are variables of the data type class. Once a class has been defined, we can create only number of objects belonging to that class. Each object is associated with the data of type class with which they are created. A class is thus a collection of objects of similar type. For example, mango, apple and orange are members of the fruit. Classes are user-defined data types and behave like the built-in types of programming languages. The syntax used to create an object is no different than the syntax used to create an integer object in C. If fruit has been defined as a class, then the statement.
Fruit mango;
Will create an object mango belonging to the class fruit.

Data Abstraction and Encapsulation:
The wrapping up of data and function into a single unit (called class) is known as encapsulation. Data encapsulation is the most striking feature of a class. The data is not accessible to the outside world, and only those functions, which are wrapped in the class, can access it. These functions provide the interface between the object’s data and the program. This insulation of the data from direct access by the program is called data hiding or information hiding.
Abstraction refers to the act of the representing essential features without including the background details or explanations. Classes use the concept of abstraction and are defined as a list of abstract attributes such as size, weight and cost, and functions to operate on these attributes. They encapsulate all the essential properties of the objects that are to be created. The functions that operate on these data are sometimes called methods or member function.
Since the classes use the concept of data abstraction, they are known as Abstract Data Types (ADT).
Inheritance: Inheritance is the process by which objects of one class acquire the properties of objects of another class. It supports the concept of hierarchical classification. For example, the bird ‘robin’ is a part of the class ‘flying bird’, which is again a part of the class ‘bird’. The principle behind this sort of division is that each derived class shares common characteristics with the class from which it is derived.
In OOP, the concept of inheritance provides the idea of reusability. This means that we can add additional features to an existing class without modifying it. This is possible by deriving a new class from the existing one. The new class will have the combined features of both the classes.

Property inheritance
Polymorphism: Polymorphism is another important OOP concept. Polymorphism, a Greek term, and means the ability to take more than one form. An operation may exhibit different behaviours in different instances. The behavior depends upon the types of data used in the operation. For example, consider the operation of addition. For two numbers, the operation will generate a sum. If the operands were strings, then the operation would produce a third string by concatenation. The process of making an operator to exhibit different behaviours in different instances is known as operator overloading. Using a single function name to perform different types of tasks is known as function overloading.
Polymorphism plays an important role in allowing objects having different internal structure to share the same external interface.
Polymorphism:Dynamic Binding: Binding refers to the linking of a procedural call to the code to be executed in response to the call. Dynamic binding means that the code associated with a given procedure call is not known until the time of the call at run-time. It is associated polymorphism and inheritance.
Message Passing: Objects communicate with one another by sending and receiving information much the same way as people pass message to one another.
A message for an object is a request for execution of a procedure, and therefore will invoke a function in the receiving object that generates the desired result. Message passing involves specifying the name of the object, the name of the function and the information to be sent.

Benefits of OOP:
Through inheritance, we can eliminate redundant code and extend the use of existing classes.
The principle of data hiding helps the programmer to build secure programs that cannot be invaded by code in other parts of the program.
It is possible to map objects in the problem domain to those in the programs.
It is easy to partition the work in a project based on objects.
Object-oriented systems can be easily upgraded from small to large systems.
Message passing techniques for communication between objects makes the interface descriptions with external systems much simpler.
Software complexity can be easily managed.
Object-Oriented Languages: Languages that support programming with objects are said to be object-based programming languages. They do not support inheritance and dynamic binding. Ada is a typical object-based programming language.
Object-oriented programming incorporates all of object-based programming features along with two additional features, namely, inheritance and dynamic binding. The following statement can therefore characterize object-oriented programming:
Object-based features + inheritance + dynamic binding
Languages that support these features include C++, Smalltalk, Object Pascal and Java. There are a large number of object-based and object-oriented programming languages.

Class: A Class is a collection of objects (or)
A class is a collection of data members & member function (or)
A class is a description of an object.
Specifying a class: A class is a way to bind the data and its associated functions
together. It allows the data (and functions) to be hidden, if necessary, from external use. When defining a class, we are creating a new abstract data type
that can be treated like any other built-in data type. Generally, a class specification has two parts:
1. Class declaration
2. Class function definitions.
The class declartation describes the type and scope of its members. The class function definitions describe how the class functions are implemented.
Class class_name
{
private:
variable declaration;
variable declaration;
public:
variable declaration;
variable declaration;
};
The class body contains the declaration of variables and functions.
These functions and variables are collectively called class members. They are usually grouped uner two sections, namely, private and public to denote which of the members are private and which of them are public. The keywords private and public are known as visibility labels. Note that these keywords are followed by a colon.
The class members that have been declared as private can be accessed only from within the class. On the other hand, public members can be accessed from outside of the class also.
The variables declared inside the class are known as data members and the functions are known as member functions. Only the member functions can have access to the private data members and private functions. However, the public members(both functions and data)can be accessed from outside of the class.
Accessing Class Members : Syntax:
object-name.function-name(actual-arguments);
Ex: x.getadata(100,76.56);
Defining Member Functions:
Member functions can be defined in two places:
1. Outside of the class definition
2. Inside the class definition
Outside of the class definition : An important difference between a member function and a normal function is that a member function incorporates a membership 'identity label' in the header. This 'label' tells the compiler which class the function belongs to. The general form of a member function definition is :
return-type class-name :: function-name(argument declaration)
{
Function body
}
The membership label class-name :: tells the compiler that the function function-name belongs to the class-name. That is, the scope of the function is restricted to the class-name specified in the header line. The symbol :: is called the scope resolution operator.
Inside of the Class : When a function is defined inside a class, it is treated as an inline function. Therefore, all the restrictions and limitations that apply to an inline function are also applicable here. Normally, only small functions are defined inside the class defintions.
Making an Outside function Inline : We can define a member function outside the class definition and still make it inline by just using the qualifier inline in the header line of function definintion.
Nesting of member functions : A member function can be called by using its name inside another member function of the same class. This is known as nesting of member functions.
Private Member Functions : A private member function can only be called by another function that is a member of its class. Even an object cannot invoke a private function using the dot (.) operator.
Memory Allocation for Objects : The member functions are created and placed in the memory space only once when they are defined as a part of a class specification. Since all the objects belonging to that class use the same member functions, no separate space is allocated for member functions when the objects are created. Only space for member variables is allocated separately for each object. Separate memory locations for the objects are essential, because the member variables will hold different data values for different objects.
Static Data Members : It is initialized to zero when the first object of its class is created. No other initialization is permitted.
Only one copy of that member is created for the entire class and is shared by all the objects of that class, no matter how many objects are created.
It is visible only within the class, but its lifetim is the entire program.
Static variables are normally used to maintain values common to the entire class. For example, a static data member can be used as a counter that records the occurences of all the objects.
Static Member functions : Like static member variable, we can also have static member functions. A member function that is declared static has the following properties : 1. A static function can have access to only other static members (functions or variables) declared in the same class.
2. A static member function can be called using the class name (instead of its objects) as follows :
class-name :: function-name;
Friend Functions: To make an outside function "friendly" to a class, we have to simply declare this function as a friend of the class as shown below:
class SITD
{
private:
...............
...............
public:
...............
...............
friend void cttc(void); //Declaration
};
The function declaration should be preceded by the keyword friend. The function is defined elsewhere in the program like a normal C++ function. The function definition does not use either the keyword friend or the scope operator (::). The functions that are declared with the keyword friend are known as friend functions. A function can be declared as friend in any number of classes. A friend function, although not a member function, has full access rights to the private members of the class.
A friend function possesses certain special characteristics:
1. It is not in the scope of the class to which it has been declared as friend.
2. Since it is not in the scope of the class, it cannot be called using the object of that class.
3. It can be invoked like a normal function without the help of any object.
4. Unlike member functions, it cannot access the member names directly and has to use an object name and dot member ship operator with each member name (E.g.: A.x)
5. It can be declared either in the public or the private part of a class without affecting its meaning.
6. Usually, it has the objects as arguments.
Const Member functions: If a member function does not alter any data in the class, then we may declare it as a const member functions as follows:
void mul (int, int)const;
double get_balance() const;
The qualifier const is appended to the function prototypes (in both declaration). The compiler will generate an error message if such functions try to alter the data values.
Local Classes : Classes can be defined and used inside a function or a block. Such classes are called local classes.

Friend Functions: To make an outside function "friendly" to a class, we have to simply declare this function as a friend of the class as shown below:
class SITD
{
private:
...............
...............
public:
...............
...............
friend void cttc (void); //Declaration
};
The function declaration should be preceded by the keyword friend. The function is defined elsewhere in the program like a normal C++ function. The function definition does not use either the keyword friend or the scope operator (::). The functions that are declared with the keyword friend are known as friend functions. A function can be declared as friend in any number of classes. A friend function, although not a member function, has full access rights to the private members of the class.
A friend function possesses certain special characteristics:
1. It is not in the scope of the class to which it has been declared as friend.
2. Since it is not in the scope of the class, it cannot be called using the object of that class.
3. It can be invoked like a normal function without the help of any object.
4. Unlike member functions, it cannot access the member names directly and has to use an object name and dot member ship operator with each member name (E.g.: A.x)
5. It can be declared either in the public or the private part of a class without affecting its meaning.
6. Usually, it has the objects as arguments.


Constructors: A Constructor is a special function which is invoked whenever an object is created.
The constructor name and the class name should be same. A Constructor cannot return any type of value even void. Constructors cannot be declared is static, const, and virtual.
The constructors can have arguments.
Types of Constructors:
1. Default Constructor: If a constructor with no arguments then the constructor is known as default constructor.
2. Parameter Constructor: If a constructor contains arguments then the constructor is known as parameter constructor.
3. Dynamic Constructor: If a constructor accepts argument values at run time then the constructor is known as dynamic constructor.
4. Default value Parameter Constructor: If a constructor contains default values as arguments then the constructor is known as default value parameter constructor.
5. Copy Constructor: When one object is copied into or assigned into another object then automatically a bit by bit copy is performed. This can be passed by using copy constructor. In the copy constructor a member by member copy is performed.

Destructors: A Destructor is a special function which is invoked whenever an object is destroyed.
Conditions of Destructors:
1. The destructor name and the class name should be same.
2. A class can have contains only one destructor.
3. Destructor can't have any arguments.
4. Destructors can't return any value even void.
5. Destructor must preceded by ~ (Tilde Symbol).
6. Destructors can't be declared is const, static, but destructors are can be virtual.

INHERITANCE: Deriving one class features into another class.
Introduction: Once a class has been written and tested, it can be adapted by other programers to suit their requirements. This is basically done by creating new classes, re-using
the properties of the existing ones. The mechanism of deriving a new class from an old one is called inheritance (or derivation). The old class is referred to as the base class and the new one is called the derived class or subclass.
The derive class inherits some are all of the traits from the base class. A class can also inherit properties from more than one class or from more than one level. A derived class with only one base class, is called single inheritanceand one with several base classes is called multilevel inheritance. On the other hand, the traits of one class may be inherited by more than one class. This process is known as hierarchical inheritance. The mechanism of deriving a class from another 'derived class' is known as multilevel inheritance.
Defining Derived Classes: A derived class can be defined by specifying its relationship with the base class in addition to its own details. The general form of defining a derived class is:
Class derived_classname : visibility_mode base_classname
{
............. //
............. // members of derived class
............. //
}
The colon indicates that the derived-class name is derived from the base-class. The visibility-mode is optional and, if present, may be either private or public. The default visibility-mode is private. Visibility mode specifies whether the features of the base class are privately derived or publicly derived.
When a base class is privately inherited by derived class, 'public members' of the base class become 'private members' of the derived class. When the base class is publicly inherited, 'public members' of the base class become 'public members' of the derived class.
Inheritance: We can also create a new class from already existing class without disturbing the existing class features. This is known as inheritance.
The newly created class is known as subclass or derived class. The existing class is known as super class or base class.
Types of Inheritance:
1. Single Inheritance
2. Multilevel Inheritance
3. Hierarchical Inheritance
4. Multiple Inheritance
5. Hybrid Inheritance.
1. Single Inheritance : When a class is derived from only one base class then the inheritance is known as single inheritance. The base class in the single inheritance is known as direct base class to the derived class.
2. Multilevel Inheritance : When a class is derived from a subclass of another base class then the inheritance is known as multilevel inheritance. The base class is known as indirect base class to the derived class and direct base class to the subclass. The subclass is also known as direct base class to the derived class.
3. Hierarchical Inheritance: When a multiple classes are derived from only one base class then the inheritance is known as hierarchical inheritance.
4. Multiple Inheritance: When a class is derived from more than one base classes then the inheritance is called as multiple inheritance.
5. Hybrid Inheritance: It is a combination of more than one inheritance concepts.

Advantages:
1. Reusability of the code.
2. Here base class functions and members are inherited to derived class. Hence the base class functions and members can be used in the derived class, without rewriting the class.
3. Time is saved is the time involved in designing base class is eliminated since they inherited to derived class.
4. Memory is sav edc which incurred in developing base class members and functions eliminated.
5. Since base class is an existing class and we can retriving base class functions and members into derived class.


Polymrphism : Polymorphism is one of the crucial features of OOP. It simply means 'one name, multiple forms'. We have already seen how the concept of polymorphism is implemented using the overloaded functions and operators. The overloaded member functions are 'selected' for by matching arguments,both type and number. This information is known to the compiler at the compile time and, therefore, compiler is able to select the appropriate function for a particular call at the compile time itself. This is called early binding or Static binding or static linking. Also known as compile time polymorphism, early binding simply means that an object is bound to its function call at compile time.
They are two types of polymorphism.
1. Compile time polymorphism (Early or Static Binding)
a. Function Overloading
b. Operator Overloading
2. Run time polymorphism (Late or Dynamic Binding)
a. Virtual Functiuons
b. Pure Virtual Functions

Virtual Functions: When a function is declared as virtual then the function as virtual function. A function cannot be static functions.
The base class pointer refers the current object address then the function is virtual in the base class.
Pure Virtual Functions: When a function is declared with virtual and initialized with 0 (zero). Then the function is known as pre virtual function.
Syntax of a pure virtual function :-
virtual return_type function_name(arguments) = 0;
Abstract Class : If a class contains one or more pure virtual functions then the class is known as abstract class. We cannot create any objects to the abstract class. Because it is an incomplete (base) class. We should implement the pure virtual function it is the sub class of the parent class.

Introduction : The mechanism of giving such special meanings to an operator is known as operator overloading.
Operator overloading provides a flexible option for the creation of new definitions for most of the C++ operators.
Def : To define an addtional task to an operator, we must specify what it means in relation to the class to which the operator is applied. This is done with the help of a special function, called operator function.
return type classname :: operator op(arglist)
{
Function Body //task defined
}
Operator fuctions must be either member functions(non-static) or friend functions. A basic difference between them is that a friend function will have only one argument for unary operators and two for binary operators,while a member function has no arguments for unary operators and only for binary operators. This is because the object used to invoke the member function is passed implicitly and therfore is available for the member function. This is not the case with friend functions. Arguments may be passed either by value or by reference.

RULES FOR OVERLOADING OPERATORS :
1. Only existing operators can be ooverloaded. New operators cannot be created.
2. The overloaded operator must have at least one operand that is of user-defined type.
3. We cannot change the basic meaning of an operator. That is to say, we cannot redefine the plus(+) operator to subtract one value from the other.
4. Overloaded operators follow the syntax rules of the original operators. They cannot be overridden.
5. There are some operators that cannot be overloaded.
Sizeof -> Size of Operator
. -> Membership Operator
.* -> Pointer-to-Member Operator
:: -> Scope resolution Operator
?: -> Conditional Operator
6. We cannot use friend functions to overload certain operators.
= -> Assignment Operator
() -> Function call Operator
[] -> Subscripting Operator
-> -> Class member access operator
However, member functions can be used to overload them.
7. Unary operators, overloaded by means of amember function, take no explicit arguments and return no explicit values, but, those oveloaded by means of a friend function, take one reference argument. (The object of the relevant Class).
8. Binary operators overloaded through a member function, take one explicit argument and those which are overloaded through a friend function take two explicit arguments.
9. When using binary operators overloaded through a member function, the left hand operand must be an object of the relevant class.
10. Binary arithmetic operators such as +, -, *, and / must explicitly return a value. They must not attempt to change their own arguments.
Function Overloading : The same function name can be used file different
purposes. This is known as function overloading.
Rules of Function Overloading :
1. Function name should be same.
2. The function should contain different number of arguments.
3. A function should contain different types of arguments.
4. Function overloading can't depend on the return type of the function.
Function Overloading or Method Overloading and Function Declaration:
More than one function same name with different types of arguments is called
function overloading.
Here parameters can be differentiate either number of parameters or datatypes
of parameters.

Exception Handling:
Introduction :
The two most common types of bugs are logic errors and syntatic errors. The logic errors occurs due to poor syntatic errors arise due to poor understanding of the language itself. We can detect these errors by using exhaustive debugging and testing procedures.
We often come across some peculiar problems other than logic or syntax errors. They are known as exceptions.
Excption Handling Mechanism :
Basics of Exception Handling :
Excepitions are of two kinds, namely, synchronous exceptions and asynchronous exceptions. Errors such as "out-of-range index" and "over-flow" belong to the synchronous type exceptions. The errors that are caused by events beyond the control of the program (such as keyboard interrupts) ae called asynchronous exceptions. The proposed exception handling mechanism in C++ is designed to handle only synchronous exceptions.
The purpose of the exception handling mechanism is to provide means to detect and report an "exceptional circumstance" so that appropriate action can be taken. The mechanism suggests a separate error handling code that performs the following tasks:
1. Find the problem (Hit the exception).
2. Inform that an error has occured (Throw the exception).
3. Receive the error information (Catch the excepion).
4. Take corrective actions (Handle the exception).
The error hanling code basically consists of two segments, one to detect errors and to throw exceptions and to take appropriate actions.
Exception Handling Mechanism :
C++ exception handling mechanism is basically built upon three keywords, namely, try, throw, and catch. The keyword try is used to preface a block of statements (surrounded by braces) which may generate as try block. When an exception is detected, it is thrown using a throw statement in the keyword catch 'catches' the exception block, and handles it appropriately.
The catch block that catches an exception must immediately folow the try block that throws the exception. The general form of these two blocks are as folows.


Templates : It is a new concept which enable us to define generic classes and functions and thus provides support for generic programming. Generic programming is an approach where generic types are used as parameters in algorthims so that they work for a variety of suitable data types and data structures.
A template can be used to create a family of classes or functions. For example, a class template for an array class would enable us to create arrays of various data types such as int array and float array. Similarly, we can define a template for a function, say mul(), that would help us create various versions of mul() for multiplying int, float and double type values.
A template can be considered as a kind of macro. When an object of a specific type is defined for actual use, the template definition for that class is substituted with the required data type. Since a template is defined with a parameter that would be replaced by a specified data type at the time of the class or function, the templates are sometimes called parameterized classes or functions.
In C++ there are two types of templates.
1. Class template.
2. Function template.
Class Template :
The general format of a class template is:
template
class classname
{
//...............
//class member specification
//with anonymous type T
//wherever appropriate
//...............
};
A class created from a class template is called a template class. The syntax for defining an object of a template class is
classname objectname(arglist);
This process of creating a specific class from a class template is called instantiation.
Function Template : Like class templates, we can also define function templates that could be used to create a family of functions with different argument types.
template
returntype functionname (arguments of type T)
{
//..........
//Body of function
//with type T
//wherever appropriate
//..........
}
Function template with multiple parameters : Like template classes, we can use more than one generic data type in the template statement, using a comma-separated list as shown below:
template
returntype functionname(arguments of types T1,T2, .....)
{
..........
.......... (Body of function)
..........
}
Example for Templates :
void swap(int a,int b)
{
cout<<"Before swapping the values in a,b are :" <<<", "<<<"\nAfter swapping the values in a,b are :" <<<", "<<<"Before swapping the values in a,b are :" <<<", "<<<"\nAfter swapping the values in a,b are :" <<<", "<<<"Before swapping the values in a,b are :" <<<", "<<<"\nAfter swapping the values in a,b are :" <<<", "<
void swap(T x,T y)
{
T temp;
temp=x;
x=y;
y=temp;
}
The above template generic function swaps integers, floats, characters etc,.
Rules for generic function :-
1. The templates cannot be used inside the main function
2. The generic function template should be written before the main
3. The generic function cannot have prototype (function declaration).

Type Conversion : We know that when constants and variables of different types are mixed in an expression, C applies automatic type conversion to the operands as per certain rules. Similarly, an assignment operation also causes the automatic type conversion. The type of data to the right of an assignment operator is automaticaly converted to the type of the variable on the left. For example, the statements
int A;
float J = 3.4523;
A=J;
convert J to an integer before its value is assigned to A. Thus, the fractional part is truncated. The type conversions are automatic as long as the data types invloved are built-in types.

Files : The I/O system of C++ handles file operations which are very much similar to the console input and output opearations. It uses file streams as an interface between the programs and the files. The stream that supplies data to the program is known as input stream and the one that receives data from the program is known as output stream. In other words, the input stream extracts (or reads) data from the file and the output stream inserts (or writes) data to the file.

(read data) --> I/P stream --> (data I/P)--> program --> (data O/P)--> O/P stream --> (writedata) -->disk files

Introduction to programming languages:-
All the programming languages can be divided into two categories.
Machine oriented languages (or) Low level languages:-
These languages have been designed to give a better machine efficiency,
i.e., Faster program execution.
Eg. : Assembly language, Machine Language.
Problem Oriented Languages (or) High Level Languages :-
These languages have been designed to give a better programming efficiency,
i.e., faster program development.
Eg. : FORTRAN, BASIC, PASCAL etc.,
Steps to learning English language:-

Steps to learning computer (programming) language :-



Introduction to C Language :-
C is a programming language developed at AT & T’s Bell Laboratories of USA in 1972. It was designed and written by a man named “Dennis Ritchie”.
C stands in between the above two [(a) & (b)] categories of languages. That is why it is often called a middle level language, since it was designed to have both: a relatively good programming efficiency (as compared to Machine Oriented Languages) and a relatively good machine efficiency (as a compared to problem oriented languages).
The C character set :
A character denotes any alphabet, digit, or a special symbol used to represent information. Following table shows the valid alphabets, numbers and special symbols allowed in C:

Alphabets A, B, C ... Z
and
a, b, c ... z
Digits 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Special Symbols ~ à Tilde
! à Exclamation mark
# à Harsh
% à Percentage
^ à Cap or Crown or Carrot
& à Ampersand
* à Asterisk
( à Open parentheses
) à Closing parentheses
_ à Underscore
- à Minus
+ à Plus
= à Equal
| à Pipe
\ à Backward slash { à Open brace
} à Closing brace
[àOpen bracket
] àClosing bracket
: à Colon
; à Semi colon
“à Double quotation mark
’ à Single quotation mark
< à Less than
> à Greater than
, à Comma
. à Dot
? à Question mark
/ à Forward slash

Constants, Variables (Identifiers): -
The alphabets, numbers and special symbols when properly combined form constants, variables and keywords. Let us see what are constants and variables in C. A constant is a quantity that does not change. This quantity can be stored at a location in the memory of the computer. A variable can be considered as a name given to the location in memory where this constant is stored. Naturally that content of the variable can change.
Eg. : 3x2 + 4x + 5 = 0
Here, 3,4, 5 and 0 cannot change, they are called constants, whereas the quantities x can vary or change hence this is called a variable.
Types of C constants :-
C constants can be divided into two major categories:
Primary constants,
Secondary constants

Rules for constructing Integer Constants :
An integer constant must have at least one digit.
It must not have a decimal point
It could be either positive or negative
If no sign precedes an integer constant it is assumed to be positive
No commas and blanks are allowed within an integer constant.
The allowable range for integer constants is –32768 to +32767 (Because an integer constant occupies 2 bytes of memory in computer).
Integer constants must fall within this range because the IBM compatible microcomputers are usually 16 bit computers which cannot support a number falling out side the above mentioned range. For a 32 bit computer of course the range would be much larger.
E.g. 450, + 590, -267
Rules for constructing Real Constants:-
Real constants are often called floating point constants. The real constants could be written in two forms, Fractional form and Exponential form.


Rules for fractional form:-
A real constant must have at least one digit
It must have a decimal point
It could be either positive or negative. Default sign is positive
No commas & blanks are allowed within a real constant.
E.g. 296.0, +1.272, -48.01
Rules for Exponential form:-
The exponential form of representation of real constants is usually used if the value of the constant is either too small or too large. If however does not restrict us in any way from using exponential form of representation for other real constants.
In exponential form of representation, the real constant is represented in two parts. The part appearing before ‘e’ is called mantissa, whereas the part following ‘e’ is called exponent.
The mantissa part and the exponential part should be separated by a letter ‘e’
The mantissa part may have a positive or negative sign. Default sign is positive.
The exponent must have at least one digit which must be a positive or negative integer. Default sign is positive.
Range of real constants expressed in exponential form is –3.4e38 to 3.4e38. (Because a floating point constant occupies 4 bytes of memory in computers).
Eg. : +5.2e-7,
4.5e8,
-0.2e+3
Note: 5.2e-7 = 5.2 x 10-7
4.5e8 = 4.5 x 108
Rules for constructing character constants :-
A character constant is either a single alphabet, a single digit or a single special symbol enclosed within single inverted commas both the inverted commas should point to the left( ’ ).
Eg. : ‘A’ is not a valid character constant
’A’ is a valid character constant.
The maximum length of a character constant can be 1 Character.
Range of character constants expressed in signed integers is –128 to +127 (or) expressed in unsigned integers is 0 to 255. Because a character constant occupies 1 byte of memory in computer.
Rules for constructing variable names :-
A variable name is any combination of 1 to 8 alphabets, digits, or underscores ( _ ). Some compilers allow variable names whose length could be up to 40 characters. Still, it would be safer to stick to the rule of 8 characters.
The 1st character in the variable name must be an alphabet.
No commas or blanks are allowed within a variable name.
No special symbol other than an underscore ( _ ) can be used in a variable name.
Eg. : empname, bas_sal, varl …. etc.
Data Types of C Variables :-
In C, a quantity which may vary during program execution is called a variable. Variable names are names given to locations in the memory of computer where different data are stored. These locations can contain integer, real or character constants. In any language, the type of variables that it can support depends on the types of data that is can handle. This is because a data stores in a location with a particular type of variable name can hold only that type of data. For example, a data stored in a memory location with an integer variable name, must be an integer data, one stored in location with a real variable name must be a real data and the one stored in location with a character variable name must be a character data. The following are the keywords for these data types.
Integer data type à int
Real data type à float
Character data type à char


C Keywords:
Keywords are the words whose meaning has already been explained to the C compiler (or in abroad sense to the computer). The keywords cannot be used as variable names because if we do so we are trying to assign a new meaning to the keyword, which is not allowed by the computer. The keywords are also called “Reserved Words”. There are only 32 keywords available in C, following is the list of keywords in C.
auto double if static
break else int struct
case enum long switch
char extern near typedef
const float register union
continue far return unsigned
default for short void
do goto signed while
C Instructions ( Expressions (or) Statements):
There are basically four types of instructions in C.
(a) Type Declaration Instruction
(b) Input / Output Instruction
(c) Arithmetic Instruction
(d) Control Instruction
Type Declaration Instruction :
This instruction is used to declare the type of variables being used in the program. Any variable used in the program must be declared before using it in any statement. The type declaration statement is usually written at the beginning of the C program.
Eg. : int basic;
float hra, ta, da;
char gender;


Input / Output Instruction :
These are used to perform the function of supplying input data to a program and obtaining the output results from it.
Eg. : scanf (“%d”,&basic); /* input instruction .*/
printf (“%d”, basic); /* output instruction.*/
Arithmetic Instructions :
A C arithmetic instruction consists of a variable name on the left hand side of = and variable names and constants on the right hand side of = the variables and constants appearing on the right hand side of = are connected by arithmetic operators like +, -, *, and /.
Eg. : perimet = 2 * (b+l);
Here, *, + are arithmetic operators,
= is the assignment operator,
2 is an integer constant,
perimet, b, l are the variables, which are declared in declaration section.
The variables and constants together are called ‘operands’ which are operated upon by the “arithmetic operators” and the result is assigned, using the assignment operator (=), to the variable on left hand side.
Note :
* C allows only one variable on left hand side of =
i.e. z = k*l is legal,
Whereas k*l = z is illegal
* A statement similar to arithmetic instruction is many times used for storing character constants in character variables.
i.e. a = ’F’ is also an arithmetic instruction.
* Arithmetic operations can be performed on ints, floats, and chars.
i.e. z = ’x’ + ’y’ is perfectly valid.
Since the addition is performed on the ASCII values of the characters and not on characters themselves. The ASCII (American Secret (Standard) Code for Information Interchange) of ‘x’ and ‘y’ are 120 and 121, and hence can definitely be added.
Operators:-
1) Unary Operators :-
Any operator which operates on only one operand is called Unary operator. These are :
- à Unary minus, used to negate any number
++ à Increment by 1
-- à Decrement by 1
sizeof (variable) à This is used to return the memory size of variable in no. of bytes.
Eg. : (i) a = -a;
a++; This is called post increment
++a; This is called pre increment
a--; This is called post decrement
--a; This is called pre decrement
a = sizeof (int); which returns 2
i.e., The memory size of integer.
(2) Binary (or) Arithmetic Operators :-
Any operator which operates on two operands is called binary operator. Arithmetic operators are used to calculate arithmetic expressions. The operators are :
* à Multiplication
/ à Division
% à Modulus (or) Remainder Operator
+ à Addition
- à Subtraction
. Eg. : a = 25%4; which gives the value 1 for a
(3) Relational Operators :-
These operators are used to compare two variables.
< à Less than
< = à Less than & equal to
> à Greater than
> = à Greater than or equal to
= = à Equal to
! = à Not equal to
(4) Logical Operators :
These operators are used to compare multiple conditions at a time.
&& à And
|| à Or
! à Not
Assignment Operators :
These operators are used to store values of some variables into another.
=, *=, /=, %=, +=, - =, &=, ^=, |=, <<=, >>=
Eg. : (i) a = 15%4;
(ii) a * = 4; which is also written as a=a*4; which means that a is multiplied by 4 and restores it.
Bitwise Operators :
These operators are used to operate with bits (i.e. 0’s and 1’s).
~ à One’s complement
<< à Left Shift
>> à Right Shift
& à Bitwise AND
^ à Bitwise XOR (Exclusive OR)
| à Bitwise OR
Structure of C :
C language has a structured way for constructing a C program, that is why C is called a structured programming language.



[ Documentation Section ]
[ Linkage Section ]
[Global declaration section ]
< main ( )
{
Local declaration section;
……………………..
……………………..
Body of main ( ) ;
……………………..
……………………..
} >

[ Function definition section ]
Documentation section :
This section is used to give the information about the program to other users.
This is also called comments section
Comment about programme should be enclosed within /*...*/.
Any no. of comments can be given at any place in the program.
Comments cannot be nested
i.e., /* calculation of /* simple x/ interest */ is invalid.
A comment can be split over more than one line.
Eg. : /* calculation of simple interest.
Author : Y. Kanitkar
Date : 25-07-2005 */
Linkage Section:
This linkage section is used to link one file to another. For this we use the preprocessor directive #include. This directive causes one file to be included in another. The preprocessor command for file inclusion books like this :
# include “filename” (or) # include <>
And it simply causes the entire contents of filename to be inserted into the source code at that point in the program.
The meanings of each of these forms :
# include “filename” : This command would look for the given file in the current directory as well as the specified list of directories as mentioned in the include search path that might have been set up.
E.g:- # include “C:\TC\decimal.C”
# include : This command would look for the given file in the specified list of directories only.
Eg. : # include
Global declaration section :
This section is used to declare the global variables i.e., This global variables are used in entire program.
Eg. : int sal;
float hra;
In this section we have another feature, that is macro definition #define directive or more commonly just a “macro”.
Syntax for macro definition.
# define
Eg. : #define PI 3.1415
Here, PI is called macro template,
3.1415 is called macro expansion
In C programming it is customary to use capital letters for macro templates.
Macro templates and macro expansions are separated by blanks or tabs.
Space between # and define is optional
Macro definition is never to be terminated by a semi colon (;).
main ( ) :
Any C program is nothing but a combination of functions. main ( ) is one such functions. Empty parentheses {( )} after main are necessary.
The set of statements belonging to a function are enclosed within a pair of braces ({}).
Any variable used in the program must be declared before using it.
Eg. : int p, n;
float r, si;
Function definition section :
This section is used to define user defined functions, if necessary.
In the above structure of C, the documentation section, linkage section, global declaration section, and function definition section are optional, and the main ( ) block is essential for every C program.
Note :
Statement in between [ ] is optional
Statement in between < > is essential
Rules for constructing C program :
Blank spaces may be inserted between two words to improve the readability of the statement. However, the blank spaces are not allowed within a variable, constant or keyword.
Usually all statements are entered in small case letters.
C has no specific rules for the position at which a statement is to be written. That is why it is often called a free-form language.
Any C statement always ends with a semi colon (;)
First C Program :
/* Purpose : Calculation of simple interest.
Author : Y. Kanitkar
Date : 25-7-2005
*/
# include <>
main ( )
{
int p, n;
float r, si;
p = 5000; /* Principle value */
n = 5; /* No. of years */
r = 8.5; /* Rate of interest */
si = p*n*r/100; /* Formula for simple interest */
printf (“Simple Interest is :%f”, si);
}
Note :
printf ( ) : it is used to print values of the variables on the screen.
The general form,
printf (“”, );
Format string could be
%f for real values (float)
%d for integer values
%c for character values.
Calculation of simple interest, using scanf() function.
main ( )
{
int p, n;
float r, si;
printf (“\n Enter principle, no.of years, rate:”) ;
scanf (“%d %d %f”, &p, &n, &r);
si = p*n*r/100;
printf (“\n simple interest = Rs. %f /-“, si);
}
Note :
scanf ( ) : This function is used to take values from keyboard. The ampersand (&) before the variable in the scanf statement is a must. & is a pointer operator, it is called address of value operator.
CONTROL INSTRUCTIONS IN C
As the name suggests the “Control Instructions” enables us to specify the order in which the various instructions in a program are to be executed by the computer. In other words the control instructions determine the “flow of control” in a program. There are 4 types of control instructions in C. They are :
Sequence control instruction,
Selection or Decision control instruction,
Repetition or loop control instruction,
Case control instruction.
(a) Sequence Control Instruction :
The Sequence Control Instruction ensures that the instructions are executed in the same order in which they appear in the program.
The flow of control looks like this :









(b) Selection or Decision Control Instruction :
Decision control instruction allow the computer to take a decision as to which instruction is to be executed next depending on condition, hence is called conditional statement.
if :-
Syntax :- if ()
Statement(s);
Here, if the given condition is true then the statements in if block will execute, otherwise that statements will ignore by the compiler.
Eg. : if (a = = o)
printf (“ a is vanish”);

(2) if .. else :-
Syntax : if ()
statement(s);
else
statement(s);


Here, if the given condition is true then the if block will execute, or if the condition is false then the else block will executed.
Eg : if (a < 0)
printf (“a is a –ve value”);
else
printf (“a is a +ve value”);
(3) if.. else if :-
syntax : if ()
statements1;
else if ()
statements2;
else
statements3;
Eg. : if (a < 0)
printf (“a is –ve”);
else if (a>0)
printf (“a is +ve”);
else
printf (“a is zero”);
(4) Nested if … else :-
Syntax :- if ()
{
statements ;
if ()
statements;
……
……
else
statements;
}
else
statements;
else if ladder :-
Syntax :-
if ()
Statements;
else if ()
Statements;
else if ()
Statements;
……….
……….
else
Statements;
Conditional operator (or) Ternary Operator :-
The conditional operators ? and : are some times called ternary operators since they take three arguments. In fact, they form a kind of foreshortened if .. then .. else.
Syntax :- Expression 1? Expression 2 : expression 3;
Here, if expression 1 is true (that is if the value is non-zero), then the value returned will be expression 2 otherwise the value returned will be expression 3.
Eg. : (i) (a<0) ? printf (“a is –ve”) : printf (“a is +ve”);
(ii) y = ((a>=65 && a<=90) ? 1:0);
Repetition & Loop Control Instructions :-
The Loop Control Instructions helps computer to execute a group of statements repeatedly. The versatility of the computer lies in its ability to perform a set of instruction repeatedly. This involves repeating some portion of the program either a specified number of times or until a particular condition is being satisfied. This repetitive operation is done through a loop control structure.
C allows us three types of loop contract structures viz.,
while
do…while
for
while :-
Syntax : -
[initialize counter;]
while (condition)
{
Body of loop;
[Increment/decrement counter;]
}
Here, the statements within the pair of braces called body of the loop. The parentheses after the while contains a condition. So long as this condition remains true all statements within the body of the loop keep getting executed repeatedly. The variable counter is many a times called either a ‘Loop Counter’ or an ‘index variable’.
Eg. : This loop is used to print 1 to 1000 numbers on the screen.
i = 1;
while (i< = 1000)
{
printf (“\n %d”, i);
i++;
}
do … while :-
Syntax :- do
{
body of do…while;
}while (condition);
The do..while loop works like a while loop. The do…while tests the condition after having executed the statements within the loop. This means that do…while would execute its statements at least once, even if the condition fails for the 1st time itself.
Eg. :- i = 1
do
{
printf (“\n %d”, i);
i ++;
}while (i<=1000);


for :-
This is probably the most popular looping control. The for allows us to specify three things about in a single line :
setting a loop counter to an initial value.
Testing the loop counter to determine whether its value has reached the number of repetitions desired.
Increasing the value of loop counter each time the program segment within the loop has been executed.
Syntax :-
for ([initialize counter]; ; [increment/decrement counter])
{
body of loop;
}







Eg. :
for (i = 1; i< = 1000; i++)
printf (“\n %d”, i);
Multiple initializations in the for loop :
* The initialize counter expression can contain more than one statement separated by a comma,
Eg. : for (i = 2, j = 1; j<=10; j++)
* Multiple statements can also be used in the increment /decrement counter expression of loop.
Eg. : for (i = 2; j = 1; j< = 10; i++; j++)
* Only one expression is allowed in condition expression. This expression may contain several conditions linked together using logical operators.
Eg. : for (i = 2, j = 1; (j<=10 && i<=20); i++, j++)
Nesting of Loops :-
Any loops within another loops are called nested loops.
Eg. :
for (i = 1; i < = 3; i++)
{
for (j = 1; j<=3; j++)
printf (“ %d”, i);
printf (“\n”);
}
The Odd Loop :
The loops that we have used so far executed the statements within them a finite number of times, i.e, decided by user at runtime are called an odd loop.
Eg. :
while (another = = ’y’)
{
printf (“Hello!”);
printf (“Do you want to another display(y/n):”);
scanf (“%c”, &another);
}
break Statement :-
The keyword break allows us to jump out of a loop instantly, without waiting to get back to the conditional test.
Eg. :
i = 2;
while (i<=num-1)
{
if (num %i = = 0)
{
printf (“Given number is not a prime number”);
break;
}
i++;
}
if (i = = num)
printf (“\nGiven number is a prime number”);
continue Statement :
The keyword continue allows us to take the control to the beginning of the loop, bypassing the statements inside the loop which have not yet been executed.
Eg. : /* To print all combinations of 1,2,3 */
for (i = 1; i<=3; i++)
for (j = 1; j<=3; j++)
for (k=1; k<=3; k++)
{
if(i = = j || j = = k || i = = k)
continue;
printf (“%d %d %d”, i, j, k);
}
d) Case control instruction :-
The control statement which allows us to make a decision from the number of choices is called a switch, or more correctly a switch-case-default, since these three keywords go together to make up the control statement.




Syntax :
switch (choice variable)
{
case constant 1 : statements; break;
case constant 2 : statements; break;
……….………………………………
………….……………………………
case constant n : statements; break;
default : statements;
}
Here, Choice variable à integer/character variable
Constants à integer/character constant
Eg. :
switch (ch)
{
case 1 : a = b + c; break;
case 2 : a = b – c; break;
case 3 : a = b * c; break;
case 4 : a = b/c; break;
case 5 : a = b%c; break;
default : printf (“\n invalid choice …!”);
}

Note:-
We can use cases in any order.
We can mix integer and character constants in different cases of a switch.
Some times there may not be any statement in some of the cases in switch, but still they might turn out to be useful.
Even if there are multiple statements to be executed in each case there is no need to enclose these within a pair of braces.
If we have no default case, then the program simply falls through the entire switch and continues with the next instruction that follows the control structure.
The break statement when used in a switch takes the control outside the switch. However, use of continue will not take the control to the beginning of switch as one is likely to believe.
A switch may occur within another switch, which is called nested switch statements.
The switch statement is very useful while writing menu driven programs.
We can have after the case is an int constant or a char constant. Even a float is not allowed.
goto statement :
This is used to jump from any statement to another statement in a C program.
Syntax : goto ;
Here, label is the target position of goto statement
i.e. : statements;
Eg. : Repeat : printf (\nenter a value :”);
scanf(“%d”,&a);
if (a<0)
goto Repeat;


POINTERS
Introduction :
Memory is organized as a sequence of byte – sized (1 byte = 8 bits) locations. These bytes are numbered beginning with a zero. The number associated with a byte is known as its address or memory location. A pointer is an entity which contains a memory address. Thus, a pointer is a number which specifies a location in memory. The key concepts and terminologies associated with memory organization are,
Each byte in memory is associated with a unique address.
Addresses are positive integer values that range from zero to some positive integer constant corresponding to the last location in the memory.
An address is an integer having fixed number of bits, labeling a byte in the memory.
Every object (data or program code) that is loaded into memory is associated with a valid range of addresses, that is, each variable and each function in a program starts at a particular location, and spans across consecutive addresses from that point onwards depending upon the size of the data item.












The size of the data type referenced by the pointer is the number of bytes that may accessed directly by using that address.
Pointers :
Pointer variables are defined as variables that contain the memory addresses of data or executable code. Normally, a pointer variable, like any other variables, is declared so that it will work only with data of a given type each pointer variable can point only to one specific type (int, float, char ….) of data.
Uses of pointers :
Accessing array elements.
Passing arguments to functions by reference.
Passing arrays and strings to functions.
Creating data structures such as linked tests, trees, graphs, and so on.
Obtaining memory from the system dynamically.
Address operator (&) :
All the variables defined in a program (including pointer variables) reside at specific addresses. It is possible to obtain the address of a program variable by using the address operator & (ampersand). When used as a prefix to the variable name, the & operator gives the address of that variable.
Eg. : a = 100;
b = &a;
Here b stores the address of variable a. Where b must be a pointer variable and declared before using it.




Pointer Variables :
Pointers are also variables and hence, must be defined in a program like any other variable. The rules for declaring pointer variable names are the same as ordinary variables.
Syntax : *;
Eg. : int *b;
Dereferencing Pointers :
Dereferencing is an operation performed to access and manipulates data contained in the memory location pointed to by a pointer. The operator *(asterisk) is used to dereference pointers. A pointer variable is dereferences when the unary operator *, in this case called the indirection operator, is used as a prefix to the pointer variable or pointer expression. Any operation performed on the dereferences pointer directly affects the value of the variable it points to. Here is an example.
Eg. : int *b, a, c = 200;
a = 100;
b = &a; // b contains address of a
*b + = 20; // dereference b, a = a +20
c = *b; // same as c= a








void Pointers :
The void pointers can contain the address of any type of variable.

Eg. : void *a, *b;
int c;
float d;
a = &c;
b = &d;
Pointers to void cannot be directly dereferences like other pointer variables by using *. Prior to dereferencing a pointer to void, it must be suitably typecast to the required data type. A pointer to void may be type cost by preceding its name with a relevant data type followed by an asterisk, both of which are enclosed within a pair of parentheses.
Eg. : printf (“c contains : %d”, ((int)a));
printf (“d contains :%f”, *((float *)b));
Pointer arithmetic :
The C language allows arithmetic operations to be performed on pointer variables.
The arithmetic operators available for use with pointers can be classified as : ++, --, +,-.
The C compiler takes the size of the data type being pointed to into account, while performing arithmetic expressions on a pointer. For example, if a pointer to an integer is incremented using the ++ operator (preceding or succeeding the pointer) then the address contained in the pointer is incremented by two and not one, assuming that an integer occupies two bytes in memory. Similarly incrementing a pointer to a float causes the initial address contained in the float pointer to be actually incremented by 4 and not 1 (float occupies 4 bytes memory).
In general, a pointer to some type, d-type (where d-type may be int, float, char…) when incremented by an integral value i, will result in the following value:
(Current address in pointer) + i * sizeof (d-type)
to be the new incremented pointer value. This concept applies to all arithmetic operations performed on pointer variables in a program. Pointer arithmetic becomes very significant for accessing and processing array elements efficiently.
Note : Pointer arithmetic cannot be performed on void pointer, since they have no type associated with them.
Pointer to Pointers :
Pointer is a type of data in C : hence we can also have pointers to pointers, just as we have pointers to integers. Pointers to pointers offer flexibility in handling arrays, passing pointer variables to functions, etc.,
Syntax : **;
Eg. : int *a, **b, c = 100;
a = &c;
b = &a;


ARRAYS AND STRINGS
ARRAY:
An array is a sequence of data in memory, where in all data are of the same type, and are placed in physically adjacent locations.
For example, a sequence of 10 integers stored one after another in memory represents an array.
E.g. :

Array declaration syntax :
array name [];
Eg. : int marks [30];
Here, the number 30 tells how many elements of the type int will be in our array. This number is often called the “dimension” of the array. The bracket [ ] tells the compiler that we are dealing with an array. This array is called ‘one dimensional array’.
Accessing array is done with subscript, the number in the brackets following the array name. This number specifies the elements position in the array. All the array elements are numbered, starting with 0. Thus, marks [2] is not the second element of the array, but the third. In our example we are using the variable i as a subscript to refer to various elements of the array.



Eg. : for (i = 0; i<=29; i++)
{
printf (”\n Enter marks:”);
scanf (“%d”, &marks [i]);
}
Note:-
An array is a collection of similar elements.
The first element in the array is numbered 0, so the last element is 1 less than the size of the array.
An array is also known as a subscripted variable.
Before using an array its type and dimension must be declared.
However big an array its elements are always stored in contiguous memory locations.
Array initialization syntax :
arrayname[] = {elements separated by commas };
Eg. : (i) int num [6] = {1,2,3,4,5,6};
(ii) int num[ ] = {15,16,81,92,53};
Till the array elements are not given any specific values, they are supposed to contain garbage values.
If the array is initialized where it is declared mentioning the dimension of the array is optional.
Forms of accessing an array element is, num [i], is represents the element in ith location, * (num + i), *(i + num), i [num] are also valid.
More than one dimensional arrays :
So far we have explored arrays with only one dimension. It is also possible for arrays to have two or more dimensions. The two dimensional array is also called a matrix.
Declaration syntax :
[dimension 1][dimension 2]...[dimension n];
Eg. : int student [10] [30];
Initializing a 2 – dimensional (2D) array :-
int matrix1[ ] [2] = {
{123, 124},
{546, 556},
{405, 306}
};
or this would work,
int matrix1 [ ] [2] = { 123, 124, 546, 556, 405, 306 };

It is important to remember that while initializing an array it is necessary to mention the second (column) dimension, where as the first (row) dimension is optional.
Memory map of a 2D array :
In memory whether it is a one-dimensional, or a two dimensional array, the elements are stored in one continuous chain. The arrangement of array elements of a two-dimensional array in memory is :

* Forms of accessing a two dimensional array element is,
num [i][j], is represents the element in ith row and jth column
*(num[i] +j), *(*(num+i)+j)
Note : In C there is no check to see if the subscript used for an array exceeds the size of the array. Data entered with a subscript exceeding the array size will simply be placed in memory outside the array; probably on top of other data, or on the program itself. This will lead to unpredictable results, to say the least, and there will be no error message to warn you that you are going beyond the array size. In some cases the computer may just hang.
STRING:
The way a group of integers can be stored in an integer array, similarly a group of characters can be stored in a character array. Character arrays are many a time also called strings.
A string constant is a one-dimensional array of characters terminated by a NULL (’\0’).
Eg. : char name [ ] = { ’C’, ’L’, ’A’, ’N’, ’G’, ’U’, ’A’, ’G’, ’E’, ’\0’};
Note :
Each character in the array occupies one byte of memory and the last character is always ’\0’.
’\0’ is called NULL character, its looks like two characters, but it is actually only one character.
’\0’ and 0 are not same. ASCII value of ’\0’ is 0, whereas ASCII value of 0 is 48.
The elements of the character array are stored in contiguous memory locations.
The terminating NULL (’\0’) is important, because it is the only way the functions that work with a string can know where the string ends.
A string not terminated by a ’\0’ is not really a string, but merely a collection of characters.
A character array is stored in memory look like this

C provides a shortcut for initializing strings.
Eg. : char name [ ] = “CLANGUAGE”;
In this declaration ’\0’ is not necessary, C inserts ’\0’ automatically.
Pointers are used to declare strings.
Eg. : char *name=”C language”;
The %s used in printf ( ) as a format specification for printing out a string. The same specification can be used to receive a string from the keyboard.
Eg. : scanf (“%s”, name);
printf (“%s”, name);
(i) The scanf ( ) function fills in the characters typed at keyboard into the array until the enter key (or) spacebar is hit. Once the enter is hit, scanf ( ) places a ’\0’ in the array. Naturally, we should pass the base address of the array to the function scanf ( ).
(ii) scanf ( ) is not capable of receiving multi-word strings. Therefore names such as “Ranga Rao” would be unacceptable.
gets ( ) : It is capable of receiving only one string at a time, the plus point with gets ( ) is it can receive a multi-word string.
Eg. : gets (name);
puts ( ) : It is used to display only one string at a time unlike printf ( ), puts ( ) places the cursor on the next line.
Eg. : puts (“Hello !”);
puts (name);
Standard Library String Functions :
With every C compiler a large set of useful string handling library functions are provided.
1) strlen ( ) : Returns the length of the given string.
Syntax : strlen();
Eg. : L = strlen (“student”); returns 7.
2) strlwr ( ) : Converts given string to lower case.
Syntax : strlwr ()
Eg : strlwr (s);
Here, if *s = “STUDENT” then after execution of the above statement it becomes *s = “student”.
3) strupr ( ) : Converts given string to upper case.
Syntax : strupr ()
Eg. : strupr (s);
Here, if *s = “student” then after execution of the above statement it becomes *s = “STUDENT”.
4) strcat ( ) : Appends one string at the end of another.
Syntax : strcat (, ),
Eg. : strcat (t, s);
Here, if t[ ] = “C ” and s[ ] = “Language” then after execution of the above statement t[ ] = “C Language”.
5) strncat ( ) : Appends 1st n characters of a string at the end of another.
Syntax : strncat (, , no. of characters);
Eg. : strncat (t, s, 1);
Here, if t[ ] = “Let Us” and s[ ] = “Clanguage”. Then after execution of the above statement, t[ ] = “Let Us C”.
6) strcpy ( ) : Copies a string into another.
Syntax : strcpy (, )
Eg. : strcpy (t,s);
Here, if t[ ]=”above” and s[ ]=”below” then after execution of the above statement t[ ] becomes “below”.
7) strncpy ( ) : Copies 1st n characters of a string into another.
Syntax : strncpy (, ,no. of characters);
Eg. : strncpy (t,s,3);
Here, if t[ ]=”above” and s[ ]=”below” then after execution of the above statement t[ ] becomes “bel”.
8) strcmp ( ) : Compares two strings. It returns the difference between ASCII values of 1st and 2nd strings.
Syntax : strcmp (, )
Eg. : (i) v = strcmp (“COMPUTER”, “COMPUTER”);
It returns “0”, i.e., The strings are equal.
(ii) v = strcmp (“Computer”, “COMPUTER”)
It returns 32, because the ASCII value of “o” is 111, and the ASCII value of “O” is 79 then ’o’-’O’ = 111 – 79 = 32
9) strncmp ( ) : Compares 1st n characters of two strings.
Syntax : strncmp (, , no. of characters),
Eg. : v = strncmp (“Computer”, “Compiler”, 4);
It returns 0 i.e. two strings, are equal at 1st 4 characters.
10) stricmp( ) (or) strcmpi( ) : Compares two strings without regard
to case . (‘i’ denotes that this function ignores case).
Syntax : stricmp (, );
Eg. : v = stricmp (“COMPUTER”, “computer”);
It returns, ‘0’, i.e., both strings are same.
11) strnicmp ( ) : Compares 1st n characters of two strings without
regard to case.
Syntax : strnicmp (, , no. of characters);
Eg. : v = strnicmp (“COMPUTER”, “Compiler”, 4);
It returns “0”.
12) strdup ( ) : Returns a duplicate a string.
syntax : s = strdup ();
where‘s’ is a character string variable (pointer)
Eg. : char *t;
t = strdup (“Computer”)
Now, *t becomes “Computer”.
13) strchr ( ) : Returns 1st occurrence of a given character in a string.
Syntax : string variable = strchr (, );
And then calculate, “ – ” for required value.
Eg. : t = strchr (str, ‘S’);
v = t – str;
Here, consider str[ ] =
It returns “2” to v.
14) strrchr ( ) : Returns lst occurrence of a given character in a string.
Syntax : string variable = strrchr (, );
Eg. : t = strrchr (str, ‘S’);
v = t – str;
Here, consider str[ ] =
It returns “6” to v.
15) strstr ( ) : Returns 1st occurrence of a given string in another string.
Syntax : string variable – strstr (, );
Eg. : t = strstr (“chairs”, “air”);
v = t – “chairs” ,It returns 2,
16) strset ( ) : Sets all characters of string to a given characters.
Syntax : strset (, );
Eg. : strset (s, ‘*’);
Here if s [ ] = “TEXT”, then after the execution of the above statement it change to s [ ] = “****”;
17) strnset ( ) : Sets 1st n characters of a string to a given character.
Syntax : strnset (, , );
Eg. : strnset (s, ‘@’, 2);
Here, if s [ ] = “TEXT”, then after the execution of the above statement it change to s [ ] = “@@XT”
18) strrev ( ) : Reverses the given string.
syntax : strrev ();
Eg. : strrev (s);
Here, if s[ ] = “DOG”, changes to s[ ] = “GOD”.
Array of strings : An array of strings is a two dimensional array of characters.
Syntax : char arrayname [dimension1] [dimension2];
The second dimension specifies the length of the longest array string and each string is accessed by “arrayname [string number]”. Here, we do not need the second index. Arrayname [string number] is sufficient to access string at string number in array.
Eg. : char names [4][10] = { “Sachin”,
“Inzamam”,
“Sourav”,
“Sanath”
};
These strings arranged in memory look like this :

Array of pointers to strings :
A pointer variable always contains an address. Therefore, if we construct an array of pointers it would contain a number of addresses (Base addresses of respective names) i.e. Base address of 1st name is stored in 1st location, and 2nd name base address is stored in 2nd location and so on.
Eg. : char * names [ ] = { “Sachin”,
“Inzamam”,
“Sourav”,
“Sanath”
};
These strings are arranged in memory look like this

In the two dimensional array of characters, the strings occupied 40 bytes. As against this in array of pointers, the strings occupy only 29 bytes. Note that in two-dimensional array of characters, the last name ended at location number 1040, whereas in array of pointers to strings, it ends at 1029. Thus, one reason to stores strings in an array of pointers is to make a more efficient use of available memory.
Limitation of array of pointers to strings :
When we are using a two dimensional array of characters we are at liberty to either initialize the strings where we are declaring the array or receive the strings using scanf ( ) function. However, when we are using an array of pointers to strings we can initialize the strings at the place where we are declaring the array, but we cannot receive the strings from keyboard using scanf ( ).
FUNCTIONS
Definition : A number of statements grouped into a single logical unit is referred to as a function.
The functions are generally divided into two categories :
(a)Pre-defined functions:-
These functions were defined, previously in the computer.
Eg. : scanf ( ), printf ( ), clrscr ( ), strlen ( ), ….etc.
(b)User –defined functions:-
These functions are defined by the user, if necessary.
Eg. : factorial ( ), sum ( ), reverse ( ), …. etc.,
The above two types of functions further classified as two types :
Value return functions, Eg. : strlen ( )
Non-value return functions, Eg. : clrscr ( ).
Function definition : This is used to write code for a user defined function in a program.
Syntax : [return type] function name (var1, var2, …. var n)
var1, var2, …, var n;
{
Body of function;
}
(or)
[return type] functionname (type var1, type var2, …, type varn)
{
Body of function;
}
The function definition is also called “called function”. In this called function the return type and var1, var2, … varn are optional
Function calling : A function gets called when the function name is followed by a semicolon (;).
Syntax : functionname (var1, var2, …, varn);
Where, var1, var2, … Varn are optional,
The parameters in called function var1, var2, … varn are called “formal parameters”. Whereas the parameters in calling function var1, var2, …, varn are called “actual parameters”.
Eg. : main ( )
{
user ( );
}
user ( )
{
printf (“\n1 am in user defined function”)
}
Note:-
C program is a collection of one or more functions.
Any C program contains at least one function.
If a program contains only one function it must be main ( ).
In a C program if there are more than one functions present, then one (and only one) of these functions must be main ( ), because program execution always begins with main ( ).
There is no limit on the number of functions that might be present in a C program.
Each function in a program is called in the sequence specified by the function calls in main ( ).
After each function has done its thing, control returns to main(). When main ( ) runs out of function calls, the program ends.
All C functions enjoy a state of perfect equality. No precedence, no priorities, nobody is nobody’s boss.
One function can call another function.
Any function can be called from any other function. Even main ( ) can be called from other functions.
A function can be called any number of times.
The order in which the functions are defined in a program and the order in which they get called need not necessarily be same.
Eg. : main ( )
{
mess1 ( );
mess2 ( );
}
mess2 ( )
{
printf (“\n This is function 2”);
}
mess1 ( )
{
printf (“\n This is function1”);
}
A function can call itself. Such a process is called “Recursion.”.
A function can be called from other function, but a function cannot be defined in another function.
Eg. : main ( )
{
printf (“\n I am in main”);
India ( )
{
printf (“\n I am in India’);
}
}
This program code gives an error.
Use of functions :
Writing functions avoids rewriting the same code over and over.
Using functions it becomes easier to write programs and keep track of what they are doing. If the operation of a program can be divided into separate activities, and each activity placed in a different function, then each could be written and checked more or less independently. Separating the code into modular functions also makes the program easier to design and understand.
E.g: Write a program to add two numbers.
main ( )
{
add ( ) ;
}
add ( )
{
int a, b;
scanf (“%d%d”, &a, &b);
printf (“\n%d + %d = %d”, a,b, a+b);
}
Passing values between functions :
The functions that we have used so far have not been very flexible. Now we want to communicate between the “calling” and the “called” functions. The mechanism used to convey information to the function is the “argument”. The arguments are sometimes also called “parameters”.
Eg. : The format string and the list of variables used inside the parentheses in the printf ( ), scanf ( ) functions are called arguments.
Program : Eg. : Write a program to calculate sum of 3 numbers using functions.
int sum(int, int, int );
main ( )
{
int a, b, c, sum;
printf (\n Enter any 3 numbers”);
scanf (“%d%d%d”, &a, &b, &c);
sum = sum3 (a,b,c);
printf (“\n Sum = %d’, sum);
}
int sum3 (int x, int y, int z)
{
int d;
d = x + y + z;
return (d);
}
* In this program, from the function main ( ) the values of a, b and c are passed on to the function sum3( ), by making a call to the function sum3( ) and mentioning a, b, and c in the parentheses :
sum = sum3 (a,b,c);
In the sum3( ) function these values get collected in three variables x, y and z : Sum3 (int x,int y,int z);
The variables a,b and c are called “actual arguments” whereas the variables x,y and z are called “formal arguments”. Any number of arguments can be passed to a function being called. However, the type, order and number of the actual and formal arguments must always be same.
Instead of using different variable names x,y,z. We could have used the same variable names a,b and c. But the compiler would still treat them as different variables since they are in different functions.
* There are two methods of declaring the formal arguments. The one that we have used in our program and another one is known as Kernighan and Ritchie (K&R) method.
i.e.,
sum3 (x,y,z)
int x,y,z;
This method is not used in these days.
* In the earlier programs the moment closing brace ( }) of the called function was encountered the control returned to the calling function. No separate return statement was necessary to send back the control.
This approach is fine if the called function is not going to return any meaningful value to the calling function. In the above program, however, we want to return the sum of x, y and z therefore, it is necessary to use the “return” statement.
The “return” statement serves two purposes :
(i) On executing the return statement it immediately transfers the control back to the calling program.
It returns the value present in the parentheses after return, to the calling program. In the above program the value of sum of three numbers is being returned.
* There is no restriction on the number of return statements that may be present in a function. Also, the return statement need not always be present at the end of the called function.
* Whenever the control returns from a function some value is definitely returned. If a meaningful value is returned then it should be accepted in the calling program by equating the called function to some variable.
Eg. : char capital(char );
main ( )
{
char a, r ;
scanf (“%c”, &a);
r = capital (a);
printf (“%c”, r);
}
char capital(char x)
{
if(x>=65 && x<=90)
return x;
else if(x>=97 && x<=122)
return x-32;
else
return ’*’;
}
* All the following are valid return statements.
return (a);
return (5);
return;
In the last statement a garbage value is returned to the calling function since we are not returning any specific value.
* If we want that a called function should not return any value, in that case, we must mention so by using the keyword void, otherwise we must mention the data type of returned value. If we do not mention the type of returned value, compiler takes default return type as integer.
Eg. : void display ( )
{
printf (“\n Be simple, be sample”);
}
* A function can return only one value at a time. Thus return (a,b) is invalid.
* If the value of a formal argument is changed in the called function, the corresponding change does not take place in the calling function.
Scope of variables : There are two types of variables available in C according to their scope.
(i) Global variables : If we declare variables in the global declaration section, then these variables are use in entire program.
(ii) Local Variables : If we declare variables in the specified function block, then these variables will work only on this function block.
E.g:
int a; /* Where ‘a’ is global variable. */
main( )
{
int b; /* Where ‘b’ is local variable in main( ). */
my( );
}
void my( )
{
int b; /* Where ‘b’ is local variable in my( ). */
printf(“%d”,b);
}
Here, the both b’s are not same.
Function declaration and prototypes :
Any C function by default returns an int value. More specifically, whenever a call is made to a function, the compiler assumes that this function would return a value of the type int. If we desire that a function should return a value other than an int, then it is necessary to explicitly mention so in the calling function as well as in the called function. And the function type is declare in the variable declaration section, this is called the “prototype” of that function.
E.g :
float square(float);
main( )
{
float a,b;
printf(“\nEnter any number:”);
scanf(“%d”,&a);
b=square(a);
printf(“\nSquare of %f is %f”,a,b);
}
float square(float x)
{
float y;
y=x*x;
return y;
}

Arguments can generally be passed to functions in one of the two ways :
(i) Sending the values of the arguments :
The “value” of each of the actual arguments in the calling function is copied into corresponding formal arguments of the called function. With this method the changes made to the formal arguments in the called function have no effect on the values of actual arguments in the calling function. This is called “call by value”.
Eg. :
main( )
{
int a=30,b=50;
printf(“\nBefore swapping: a = %d, b = %d”,a,b);
swapcbv(a,b);
printf(“\nAfter swapping: a = %d, b = %d”,a,b);
}
void swapcbv(int x,int y)
{
int t;
printf(“\nBefore swapping: x = %d, y = %d”,x,y);
t=x;
x=y;
y=t;
printf(“\nAfter swapping: x = %d, y = %d”,x,y);
}
Output :
Before swapping a = 30, b = 50
Before swap x = 30, y = 50
After swap x = 50, y = 30
After swap a = 30, b = 50
(ii) Sending the addresses of the arguments :
The “addresses” of actual arguments in the calling function are copied into formal arguments of the called function. This means that using these addresses we would have an access to the actual arguments and hence we would be able to manipulate them. This method is called “call by reference”.

main( )
{
int a=30,b=50;
printf(“\nBefore swapping: a = %d, b = %d”,a,b);
swapcbr(&a,&b);
printf(“\nAfter swapping: a = %d, b = %d”,a,b);
}
void swapcbr(int *x,int *y)
{
int t;
printf(“\nBefore swapping: x = %d, y = %d”,*x,*y);
t=*x;
*x=*y;
*y=t;
printf(“\nAfter swapping: x = %d, y = %d”,*x,*y);
}
Output :
Before swapping a=30,b=50
Before swapping x=30,y=50
After swapping x=50,y=50
After swapping a=50,b=30

Note : Using a call by reference intelligently we can make a function return more than one value at a time, which is not possible by using “call by value”.
Recursion: Expressing an entity in terms of itself is called recursion. And a function that contains a function call to itself (recursive call), or a function call to a second function which eventually calls that 1st function, is known as a recursive function
E.g. /* Recursive function for find factorial of given number.*/
int fact(int x);
void main( )
{
int n,f;
printf(“\nEnter any +ve integer:”);
scanf(“%d”,&n);
f=fact(n);
printf(“\nThe factorial value of %d is: %d”,n,f);
}
int fact(int x)
{
if(x = = 0)
return 1;
else
return x*fact(x-1);
}

Three important conditions must be satisfied by way recursive function.
Each time a function calls itself it must be closer, in some sense to a solution.
There must be a decision criterion for stopping the process or computation.
We do not use recursive calls within loops.


Arrays to functions :
Arrays can be passed as arguments to functions. Thus, just passing the address of 0th element of the array to a function is as good as passing the entire array to the function. It is also necessary to pass the total number of elements in the array; otherwise the function would not know the size of the array.
* The address of 0th element (is called base address) can also be passed by just passing the name of array
Eg. :
void main( )
{
int a[30],n;
printf(“\nEnter array size:”);
scanf(“%d”,&n);
scan(a,n);
print(a,n);
}
void scan(int *d,int x) /* Call by reference. */
{
int i;
for(i=0;i scanf(“%d”,d[i]);
}
void print(int d[30],int x) /* Call by value. */
{
int i;
for(i=0;i printf(“%d\t”,d[i]);
}
DATA TYPES AND STORAGE CLASSES
The primary data types themselves could be of several types, viz.,
Integers, long and short :
* An integer constant is any number in the range –32768 to +32767. This is because an integer constant always occupies two bytes in memory.
* Out of the two bytes used to store and integer, the highest bit (16th bit) is used to store the sign of the integer.
This bit is 0, if the number is +ve.
1, if the number is –ve
* Long integers would occupy 4 bytes of memory. These variables are declared using the keyword “long”.
Eg. : long int a ; (or) long a;
* Long integers cause the program to run a bit slower, but the range of values that we can use is expanded from –2147483648 to +2147483647.
* If we add the suffix ‘L’ or ‘l’ at the end of the number, it indicates it is long integer.
Eg. : 45 is an integer and would occupy two bytes, whereas 45L is a long integer and hence would occupy 4 bytes of memory.
* short int is nothing but our ordinary int.
* short int are need less space in memory and thus help speed up program execution.
Eg. : short int a; (or) int a;
Integers, signed and unsigned :
* Unsigned integers are used to represent only +ve numbers. The 16th bit is now free and is not used to store the sign of the number, unsigned int still occupy two bytes.
Eg. : unsigned int a; (or) unsigned a;
By default short int is a signed short int and a long int is a signed long int.
Chars, signed and unsigned :
* Both signed char and unsigned char occupying one byte each, but having different ranges.
* A signed char is same as our ordinary char and has a range from –128 to +127.
* An unsigned char has a range from 0 to 255.
Floats and doubles :
* A float occupies 4 bytes in memory and can range from –3.4e38 to +3.4e38.
* A double occupies 8 bytes in memory and can range from –1.7e308 to +1.7e308.
Eg. : double a;
A long double occupies 10 bytes in memory and can range from –1.7e4932 to 1.7e4932.
Eg. : long double a;

Data type Range Bytes Format
signed char -128 to +127 1 %c
unsigned char 0 to 255 1 %c
short signed int -32768 to +32767 2 %d
short unsigned int 0 to 65535 2 %u
long signed int -2147483648 to +2147483647 4 %ld
long unsigned int 0 to 4294967295 4 %lu
float -3.4e38 to + 3.4e38 4 %f
double -1.7e308 to +1.7e308 8 %lf
long double -1.7e4932 to + 1.7e4932 10 %Lf
Scope : Scope of a variables can be defined as the region over which the variable is visible or valid. We shall deal with scope fewer than two categories.
(i) Block scope : A block is defined as a sequence of statements enclosed between curly braces ({&}).
In other words, a block is a compound statement.
Eg. A function body is a block, because it is simply a sequence of statements enclosed within curly braces.
This is referred to as nesting of blocks.
(ii) File scope : Variables declared outside all functions are said to have global scope. Global variables can be classified under two categories.
Static (or) file static variables, whose scope is limited to the file in which it is declared,
Global variables, which can be accessed across files which are linked together.
Extent : The period of time during which memory is associated with a variable is called the extent or life of the variable.
Storage classes : The life time of a variable is characterized by its storage class. The storage class of a variable indicates the allocation of storage space to the variable. Thus, storage classes define the extent of a variable.
Storage class tells us,
* Where the variable would be stored.
* What will be the initial value of the variable, if the initial value is not specifically assigned. (i.e. the default initial value)
* What is the scope of the variable i.e., in which functions the value of the variable would be available.
* What is the life of the variable i.e. how along would the variable exists.
There are 4 storage classes in C
(a) Automatic storage class à auto
(b) Register storage class à register
(c) Static storage class à static
(d) External storage class à extern
(a) Automatic storage class :
All variables declared within a function are auto by default. The extent of a variable is defined by its scope. Variables declared auto can only be accessed only within the function or the nested block within which they are declared. They are created when the block is entered into and destroyed when it is exited.
Storage à Memory
Default initial value à An unpredictable value, which is often called a
garbage value.
Scope à Local to the block in which the variable is defined.
Life à Till the control remains within the block in which
the variable is defined.
Eg. : auto int a; (or) auto a;
Program :
void main( )
{
auto int i=1;
{
auto char i=’B’;
{
auto int i=5;
printf(“%d\n”,i);
}
printf(“%c\n”,i);
}
printf(“%d\n”,i);
}
Sample run:-
5
B
1


Register storage class :
C allows the use of the prefix “register” in primitive variable declarations. Such variables are called register variables, and are stored in the registers of the microprocessor (CPU). The number of variables which can be declared register are limited. If more variables are declared as register variables, they are treated as auto variables. Because the number of CPU registers are limited (14 in case of micro computers), and they may be busy doing some other task. A value stored in a CPU register can always be accessed faster than the one which is stored in memory. Therefore, if a variable is used at many places in a program it is better to declare its storage class as register. Good examples of frequently used variables are loop counters. We cannot use register storage class for all types of variables. Because the CPU registers in a microcomputer are usually 16 bit registers and therefore cannot hold a float value or a double value, which require 4 and 8 bytes respectively for storing a value.
Storage à CPU registers
Default initial value à Garbage value
Scope à Local to the block in which the variable is defined.
Life à Till the control remains within the block in which
the variable is defined.
Eg. :
void main( )
{
register int i;
for(i=0;i<=100;i++)
printf(“%d\n”,i);
}
c) Static storage class :
Use “static” storage class only if you want the value of a variable to persist between different function calls. A typical application of this storage class is recursive functions.
Storage à Memory
Default initial value à Zero
Scope à Local to the block in which the variable is defined.
Life à Value of the variable persists between different
function calls.
Eg. :
void main( )
{
static int i;
if(i<=10)
{
printf(“%d”,i++);
main( );
}
}
Sample Run : 012345678910
(d) External storage class :
Use “extern” storage class for only those variables which are being used by almost all the functions in the program. This would avoid necessary passing of these variables as arguments when making a function call. Declaring all the variables as extern would amount to a lot of wastage of memory space because these variables remain active throughout the life of the program.
Storage à Memory
Default initial value à Zero
Scope à Global
Life à As long as the program’s execution does not come
to an end.
Eg. : extern int a;
STRUCTRURE AND UNIONS
Structure :
A structure contains a number of data types grouped together. These data types may or may not be of the same type.
Syntax :
struct
{
;
;
………………………………
………………………………
;
} [structure type variables];
Here, the identifier “” is called “structure tag” or simply “tag”. This tag is considered to be a new type defined by the user. No memory has been allocated to the structure so far. To use this structure in a program, we must define a structure variable as :
struct ;
or in the above style.
Eg. :
struct employee
{
char name[20];
int number;
float salary;
} emp1,emp2;



(or)
struct employee
{ char name[20];
int number;
float salary;
} ;
struct employee emp1,emp2;
Here, the statement defines a new data type called struct employee. Each variable of this data type will consists of a character variable ‘name’, an int variable ‘number’, and a float variable ‘salary’.
* The closing brace ( }) in the structure type declaration must be followed by a semicolon (;).
* It is important to understand that a structure type declaration does not tell the compiler to reserve any space in memory. All a structure declaration does is it defines the ‘form’ of the structure.
* Usually structure type declaration appears at the top of the source code file, before any variables or functions are defined. In very large programs they are usually put in a separate header file, and the file is included in whichever program we want to use this structure type.
Accessing structure elements : In structures we can access individual elements of a structure using a dot (.) operator.
Eg. : emp1.salary, is refer to salary of emp1.
* Note that before the dot there must always be a structure variable and after the dot there must always be a structure element.
Storage of structure elements : Whatever be the elements of a structure, they are always stored in contiguous memory locations.
Eg. : struct employee emp1 = { “Ram”, 34,2000.0};
Memory map of structure elements




It is possible to declare an array of structures. The array will have individual structures as its elements.
Eg. :
struct employee
{
char name[20];
int number;
float salary;
} employs[1000];
Here, employs is an array of 1000 employee structure. Each element of the array employs will contain the structure of type employee. The employee structure consists of three individual members: an array name, number and salary.
The syntax we use to reference each element of the array employs is similar to the syntax used for arrays of ints and chars.
E.g:
employs[0].name, is used to refer the 1st employee name.
employs[938].number, is used to refer the 939th employee number.
In an array of structures all elements of the array are stored in adjacent memory locations. Since each element of this array is a structure, and since all structure elements are always stored in adjacent locations you can very well visualize.
Eg. : employs [0]’s name, number and salary would be immediately followed by employs [1]’s name, number, and salary and so on.
The values of a structure variable can be assigned to another structure variable of the same type using the assignment operator. It is not necessary to copy the structure elements “piece-meal”. Obviously, programmers prefer assignment to piece-meal copying.


E.g:
void main( )
{
struct employee
{
char name[20];
int number;
float salary;
}e1,e2;
struct employee e3={ “Sachin”,5,20000.50};
/* Piece-meal copying */
strcpy(e1.name,e3.name);
e1.number=e3.number;
e1.salary=e3.salary;
/* Copying all elements at a time */
e2=e3;
printf(“\n%s\t%d\t%f”,e1.name,e1.number,e1.salary);
printf(“\n%s\t%d\t%f”,e2.name,e2.number,e2.salary);
printf(“\n%s\t%d\t%f”,e3.name,e3.number,e3.salary);
}
One structure can be nested within another structure using this facility complex data types can be created.
Eg. :
struct students
{
char name[20];
int number;
struct date
{
int day;
int month;
int year;
}doj;
int marks;
}student1;
Here, student1.doj.month refers the student1’s month of joining and student1.doj.year refers the student1’s year of joining.
A structure variable can also be passed to a function. We may either pass individual structure elements or the entire structure at a time.
Eg. :
Display(e1.name,e1.number,e1.salary); /* calling */
void Display(char *s,int n,float a) /* definition */
{
printf(“\n%s\t%d\t%f”,s,n,a);
}
(or)
Display(e1); /* calling */
void Display(struct employee e) /* definition */
{
printf(“\n%s\t%d\t%f”,e.name,e.number,e.salary);
}
We can have a pointer pointing to a structure. Such pointers are known as “structure pointers”. In such cases C provides an operator ‘->’, called an “arrow operator” to refer to the structure elements. Remember that on the left hand side of the “.” Structure operator, there must always be a structure variable, whereas on the left hand side of the “->” operator there must always be a pointer to a structure.


E.g:
void main( )
{
struct employee
{
char name[20];
int no;
float sal;
} *ptr;
struct employee e1={“Aswin”,512,2000.0};
ptr=&e1;
printf(“\n%s\t%d\t%f”,e1.name,e1.no,e1.sal);
printf(“\n%s\t%d\t%f”,ptr->name,ptr->no,ptr->sal);
}
This structure in memory

Note : - Initialization not allowed in structure declaration.
UNIONS :
A union is a data type in C which allows the overlay of more than one variable in the same memory area. All variables inside a union share storage space. The compiler will allocate sufficient storage for the union variables to accommodate the largest element in the union. Other elements of the union use the same space. This is how a union differs from a structure. Individual variables in a union occupy the same location in memory. Thus, writing into one will overwrite the other. Elements of a union are accessed in the same manner as the elements of a structure.
Syntax:
union
{
;
;
…………………………….
…………………………….
;
} [union type variables];
E.g:
union position
{
int left;
int right;
int top;
int bottom;
} cursor1, cursor2;
Differences between structure and unions :
· The amount of memory required to store a structure variable is the sum of sizes of all the members in addition to the padding bytes that may be provided by the compiler. On the other hand, in case of a union, the amount of memory required is the same as that required by its largest member.


E.g:-
struct a
{
int i;
char ch[2];
} s;

union a
{
int i;
char ch[2];
} s;
While all the structure members can be accessed at any point of time, only one member of a union may be accessed at any given time. This is because, at any instant only one of the union variables will have a meaningful value, only that member which is last written, can be read. At this point, other variables will contain garbage.
E.g:-
if s.i=512 then s.ch[0]=0 and s.ch[1]=2
if s.ch[0]=50 then s.i=562 and s.ch[1]=2
Uses of structures and unions :
Structures are used to maintain database management
Changing the size of the cursor.
Clearing the contents of the screen.
Placing the cursor at appropriate position on screen.
Drawing any graphics shape on the screen
Receiving a key from the keyboard
Checking the memory size of the computer
Finding out the list of equipment attached to the computer
Formatting a floppy
Hiding a file from the directory
Displaying the directory of a disk
Sending output to printer
Interacting with the mouse.

I/O FUNCTIONS
There are numerous library (pere-define) functions available for I/O (input/out put). These can be classified into three broad categories:
Console I/O functions:-
Functions to receive input from keyboard and write output to VDU.
Disk I/O functions:-
Functions to perform I/O operations on floppy disk or hard disk.
Port I/O functions:-
Functions to perform I/O operation on various ports.
Console I/O functions:-
Console I/O function can be further classified into two categories:
Formatted and
Unformatted console I/O functions.

Ex:- printf( ),scanf( ) Ex:- puts( ), gets( ).
Formatted Functions:- Allow the input read from the keyboard or the output displayed on the VDU [visual display unit i.e, monitor] to be formatted as per our requirements.
Ex:- If values of average marks and percentage marks are to be displayed on the screen, than the details like where this output would appear on the screen, how many spaces would be present between the two values, the number of places often the decimal points...etc, can be controlled using formatted functions.
printf( ):- used to print values on the screen.
Syntax:- printf(“” [variables list separated by commas]);
Format string contains:
Characters that are simply printed as they are
Conversion specification that being with “a%” sign.
Escape sequences the being with a”\” sign.

Data Type Format Convention Character
int Integer
Long integer
Unsigned int %i, %p, %hd, %hi
%li
%hu
Hexadecimal
Octal %x, %lx
%o, %lo
Float float (exponential)
double
%e, %E, %g, %G
%le, %lf, %lg,
%he, %lf, %lg

None % %
We can provide following optional specifies in the conversion specifications.

Specifier Description
Dd digits specifying field width
.dd
decimal point separating field width from precision[precision stands for the number of place after the decimal point]
digits specifying precision

- minus sign for left justifying the output in the specified filed width.
E.g. (1) printf(“\nWeight is %d kg”,63);
(2) printf(“\nWeight is %6d kg”,63);
printf(“\nWeight is %-6d kg”,63);

output:-

0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
W e i g h t i s 6 3 k g
W e i g h t i s 6 3 k g
W e i g h t i s 6 3 k g
(ii) printf(“\n%10.2f%10.1f”, 305.6542,3000.956)
output:-

0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
3 0 5 . 6 5 3 0 0 1 . 0
(iii) printf(“%20s”, “INDIA”)
output:-

0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
I N D I A
Escape Sequences:-
These are used to print the output on the screen where we want.

Esc. Sequence Purpose Esc. Sequence Purpose
\n new line \t tab space
\b back space

\f form feed
\` single quote
\\ back slash
\” double quote \a alert(beep sound)
Eg:- printf(“he said, \” lets do it !\” “);
Output:- he said, “let’s do it !”
printf(“welcome\t to\t the\n computer\t world”);
Output:- welcome to the
Computer world.
Note:- printf( ) uses the specification that we mention and attempts to perform. The specified conversion, and does its best to produce a proper result
Eg:- printf(“%c”, 65);
Output: A
scanf( ):- used to take values from keyboard.
Syntax:- scanf(“”, );
We are sending addresses of variables (addresses are detained by using `&` the `address of ` of operator) to scanf( ) functions this is necessary because the values corresponding to these addresses. The values that are supplied thought the keyboard must be separated by either blanks, tabs or new lines. Do not include these escape sequences in the format string.
Ex:- scanf(“%d%f”, &b, &c);
White space characters:
If scanf( ) encounters a white space characters in the format string, it reads, but doesn’t store consecutive white space characters till the next non-white space character in the input.
Ex:- scanf(“%d/%d/%d”, &day, &month, &year);
Input:- 01/02/2005
cprintf( ), cscanf( ):- these are used similarly printf( ), scanf( ) function.
sprintf( ):- Instead of sending the output to the screen, this function writes the output to an array of characters.
Syntax:- sprintf(, “”, );
sscanf( ):- Instead of taking the input from the keyboard, this function takes the input from an array of characters.
Syntax:- sscanf(, “”, &);
Unformatted functions:
There are several standard library functions available under this category. Those which can deal with a single character and those which can deal with a string of characters.
getche( ):- Used to read a single character, the instant it is typed without waiting for the enter key to do hit. This function return the character that has been most recently typed. The `e` in getche( ) function means it echoes (displays) the character that you typed to the screen.
Ex:- ch=getche( ); // ch is a character variable.
getch( ):- This is work like getche( ), but it returns the character that you typed without echoing it on the screen.
Ex:- ch=getch( );
getchar( ):- This is a macro, it works similarly and echoes the character that you typed on the screen, but it requires enter key to be typed following the character that you typed.
Ex:- ch=getchar( );
fgetchar( ):- This is a function, it works similarly getchar( );
Ex:- ch=fgetchar( );
putch( ), putchar( ), fputchar( ):- These can print only one character on the screen at a time. As fas as the working of these functions is concerned its exactly some.
Ex:- putch(ch); putch(`R`);
putchar(ch); putchar(`R`);
fputchar(ch); fputchar(`R`);
gets( ):- Is capable of receiving only one string at a time, the plus point with gets( ) is it can receive a multi-word string.
Ex:- gets(name);
puts ( ):- Is capable of used to display only string at a time unlike printf( ), puts( ) places the cursor on the next line.
Ex:- puts(“rahul dravid”);
puts(name);
getc( ):- getc( ) is a macro that gets one character from a stream.
Syntax:- getc();
Ex:- ch=getc(stdin);
putc( ):- putc( ) is a macro that outputs a character to a stream.
Syntax:- putc(, );
Ex:- putc(ch, stdout);

Standard File Pointer [Stream] Description
stdin Standard input device[key board]
stdout Standard output device [VDU]
stderr Standard error device[VDU]
stdaux standard auxiliary device[serial port]

stdprn
standard printing device [parallel
printer]

fflush( ):- It is designed to remove or flush out any data remaining in the buffer. The argument to fflush( ) must be the buffer which we want to flush out. Here we use “stdin”, which means buffer related with standard input device the keyboard.
Ex:- fflush(stdin);

D.M.A
(DYNAMIC MEMORY ALLOCATION)
Memory Allocation Functions:
These function are used to allocate memory space for variables dynamically, in terms of bytes.
malloc ( ): This is used to allocate given size of memory. It assigns to memory initially garbage values.
Syntax:- pointer variable=(return type*) malloc(size of memory);
Ex:- iptr=(int *) malloc(3* sizeof (int));
This is used to allocate 6 bytes memory for iptr.
calloc( ):- This is also used to allocate memory for given no.of items. It assigns to memory initially zero.
Syntax:- pointer variable=(return type *) calloc (no.of items, size);
Eg:- cptr=(char *) calloc(3, sizeof (char));
This is used to allocate 3 bytes memory for cptr.
realloc( ):- This is used to reallocate memory for previously allocated memory.
Syntax:- pointer variable=(return type*) realloc(block, size);
Here, block is a pointer previously allocated memory by malloc( ) or calloc( ). If block is NULL then the realloc is works like malloc( ).
Ex:- iptr=(int*)realloc(iptr, 3* sizeof (int));
free( ):- This is used to free the previously allocated memory.
Syntax:- free(pointer variable);
Ex:- free(iptr);
NOTE:- If the memory allocation is successfully created then these functions returns non-zero value otherwise it returns NULL.

FILES
Disk I/O Functions:-
Disk I/O Operations are performed on entities called files. There are a large number of standard library functions available for performing Disk or file I/O. These functions can be badly divided into two categories.
High level file I/O functions
[Standard I/O or stream I/O functions]
Low level file I/O functions
[System I/O function]
High level disk I/O functions are more commonly used in c programs, since they are easier to use than low level disk I/O functions. There is one basic difference between high low level disk I/O function high level disk I/O functions do their own buffer management. Where as in low level disk I/O functions, buffer management has to be done explicitly by the programmer.
Low level disk. I/O is harder to program than high level disk I/O. However, low level disk I/O is more efficient both in terms of operation and the amount of memory used by the program.

Before we can write in formation to a file on a discord read it, we must open the file opening a file establishes a link between the program and the operating system, about, which file we are going to access and how. We provide the operating system with the name of the file and whether we plan to read or write to it. The link between our program and the operating system is a structure called FILE which has been defined in the header file “stdio.h” Therefore, it is necessary to always include this file when we are doing high level disk I/O. When we request the operating system to open a file, what we get back, is a pointer to the structure FILE. We must declare the FILE pointer before opening the file.
Syntax:- FILE ;
Each file we open will have its own FILE structure. The FILE structure contains information about the file being used, such as its current size, its location in memory etc. More importantly it contains a character pointer which points to the character that is about to get read. Where pointer variable contains address of the structure FILE.
Ex:- FILE *fp;
Opening of a file:-
fopen( ) is used to open a file. If an fopen( ) statement is successfully open a file. The it will return the address of that file, otherwise it will returns a NULL.
Syntax:- =fopoen(“”,””);
File opening modes:- The high level disk I/O functions can be categorized as text and binary. This classification arises out of the mode in which a file is opened. The are three main areas where text and binary mode files are different these are:
Handling of new lines:-
In text mode, a new line character is converted into the carriage return line feed combination before being written to the disk. Likewise the carriage return line feed combination on the disk, is converted back into a new line when the file is read by a C program. However, if a file is opened in a binary mode as opposed to text mode, these convert ions will not take place.
Representation of end of file:-
In text mode a special character, whose ASCII value is 26, inserted after the last character in the file to mark the end of file. If this character is detected at any point in the file, the read function would return the EOF signal to the program. As against this, there is now such special symbol or character present in the binary mode files keep track of the end of file from the number of character present in the directory entry of the file.
Storage of numbers:-
Numbers are stored as strings of character in text mode (i.e., 1234 occupies two types in memory, when transferred to the disk, it would occupy four bytes, one byte per character). In binary mode numbers are stored as binary format. It means each number would occupy same number of bytes on disk as it occupies in memory.
Types Of Modes:-

Mode Opening Possible Operations
“r” (or) “rt”, “rb” Searches file. If the file exists, loads, it into memory and sets up a pointer which point to the 1st character in it. If the file doesn’t exists it returns NULL. Reading data from the file
“w” (or) “wt”, “wb” Searches files. If the file exists, its contents are overwritten otherwise a new file is created. Return NULL, if unable to create file. Writing data to the file
“a” (or) “at”, “ab” Searches files. If the file exists, loads it into memory and sets up a pointer which pointer to the 1st character in it, otherwise a new file is created. Returns NULL, if unable to open file. Appending New contents at the end of file.
“r+” (or) “r++”, “r+b”
Same as “r” Reading existing contents, writing new contents, modifying existing contents of the file.
“w+” (or) “w++”, “w+b” Same as “w” Same as “rt”
“a+” (or) “a++”, “a+b” Same as “a” Reading existing contents, appending new contents to end of file. Cannot modify existing contents.

Here, if represents text mode and “b” represents binary mode. Default mode is text mode.
Ex:- fp=open(“prime.c”, “r”);
Here, firstly it searches on the disk the file to be opened. If the file is present, it loads the file from the disk into memory. If the file is very big, then it loads the file part by part. [If the file is absent, fopen( ) returns a NULL. NULL is a macro, defined in “stdio.h” Which indicates that you failed to open the file.] It sets up a character pointer which is part of FILE structure which points to the1st character of the chunk of memory where the file has been loaded.
Closing of a file:- When we have finished reading from the file, we need to close it. This is done using the function fclose( ).
Syntax:- fclose();
Ex:- fclose(fp);
File Handling Functions:-
1.fgetc( ):- It reads the character from current pointer position, advances the pointer position so that it now points to the next character and returns the character that is read. If it reaches end of file, it will returns “EOF” character.
Syntax:- variable=fgetc(file pointer);
Ex :- ch=fgetc(fp);
The character EOF can also be generated from the keyboard by pressing “ctrl + z”.
2.fputc( ):- It writes a character to a file.
Syntax:- fputc(character , file pointer);
Ex :- fputc (ch,ft);
3.fgets( ):- It reads a string from a file. It it reaches end of file, it will return NULL.
Syntax:- fgets(string variable, length of string, file pointer);
Ex :- fgets(str,100,fp);
4.fputs( ):- It writes a string to a file.
Syntax:- fputs(string, file pointer);
Ex :- fputs(str, fp);
5. fprintf( ):- Which writes the values of variables to the file. This function is similar to printf( ), except that a FILE pointer is include as the 1st argument. As in printf( ), we can format the data in a variety of ways, by using fprintf( )
Syntax:- fprintf(file pointer,. “format string”, addresses of variables);
Ex :- fprints (fp ,“%d\t%s\t%f\n”, no,name,s);
6.fscanf( ):- used to read the data from the disk. This function is similar to scanf( ) except that a pointer to FILE included as the 1st argument. This function returns EOF at the end of the file.
Syntax:- fscanf(file pointer, “format string”, address of variables)
Ex:- fscanf(fp, “%d%s%f”, &no, name, &s);
7.fwrite( ):- This function is used to store entire record (structure) to the file.
Syntax:- fwrite(address of record, size of record no.of records, filepointer);
Ex :- fwrite(&emp, sizeof (emp),1 fp);
8.fread( ):- This function is used to retrieve the entire record from disk. This function returns “0” at the end of the file.
Syntax:- fread(address of record, size of record, no.of records, filepointer);
Ex :- fread(&emp, sizeof (emp)1, fp);
9.rewind( ):- Used to replace the cursor at the top left corner (1st position) of the file.
Syntax:- rewind (file pointer);
Ex :- rewind (fp);
10.fseek( ):- This function is used to move the pointer from one record to another.
Syntax:- fseek(file pointer, records size to move, position);


Position Meaning
SEEK_END Move the pointer from the end of file.
SEEK_CUR Move the pointer with reference to its current position.
SEEK_SET Move the pointer with reference to the beginning of the file.

Ex:- fseek(fp, sizeof (emp), SEEK_SET);
11. ftell( ):- It returns pointer position as a long int.
Syntax:- long int variable=ftell(file pointer);
Ex :- p=ftell(fp);
12. ferror( ):- Reports any error that might have occurred during a read/writer operation on a file. It returns a zero if read/writer is successful and a non-zero value in case of a failure.
13. perror( ):- Which prints the error message specified by the compiler.
Ex:- if (ferror( ))
{
perror(“error”)
break;
}
14. remove( ):- It is used to delete a file from disk.
Syntax:- remove (filename);
Ex :- remove(“simple.c”);
15. rename( ):- It is used to change the name of any existing file.
Syntax:- rename(old file name, new file name);
Ex :- rename(“simple.cf”, “sample.cpp”);
16. feof( ):- This function is used to check the file is end or not. If it is end of file then it returns a non-zero value otherwise it returns a zero.