C++ Notes

Getting Started

Need of Programming Language, Source Code, Object code, C++ Compiler, Preprocessor, Linker, Using Turbo C++ Compiler

C++ Basics

C++ Character Set, Tokens, Keywords, Identifiers, Literals, Integer constants, Character constants, Floating constants, Strings constants, Escape Sequence, Punctuators, Operators

Data Handling

Basic data types, Variables, Input/Output (I/O), Type conversion, type casting, Constants, Structure of C++ Program, Comments

Operators

Arithmetical operators, Relational operators, Logical operators, Unary operators, Assignment operator, Compound Assignment Operators, Conditional operator

Flow Of Control

Conditional Statements, if statement, if else , nested if, switch statement, Looping statement, while loop, do-while loop, for loop, Jump Statements, goto, break, continue

Library Function

#Include Directive, Mathematical Functions, Character Functions, String Functions, Console I/O functions, General purpose standard library functions, Some More Functions

Function

Prototyping, defining and calling a function, actual parameters and formal parameters, return type of a function, call by value, call by reference, inline function, default argument, global variable local variable

Array

Declaration, Initialization of 1-D Array, Referring to array elements, using loop to input array from user, array as Parameter, traverse, Read, Linear Search, Binary Search, Bubble, Insertion Sort, Selection Sort, Merge

String

Declaration, Initializing, Reading strings, Printing strings, cin, gets(), cout, puts() counting number of characters in string, count number of words, length of string, copy contents of string, concatenate, compare string

2-D Array

read a 2-D array, display content of a 2-D array, sum of two 2-D arrays, multiply two 2-D arrays, sum of rows & sum of columns of 2-D array, sum of diagonal elements of square matrix, transpose of a 2-D array

Structure

Defining a structure, Declaring Variables of Type struct, Accessing of its data members, Initialization of structure variable,Nested structure, typedef, Enumerated data type, #define, Macros

OOP Concepts

Procedural Paradigm, Object Oriented programming, Object, Class, Data Abstraction, Encapsulation, Modularity, Advantages of Object oriented programming

Classes & Objects

Classes and Objects, declaring a class, private members, protected members, public members, Example of a class

Constructors

Constructor, Types of Constructor, Default Constructor, Para-meterized Constructor Copy Constructor, Constructor overloading, Destructor

Inheritance

Inheritance, Base Class, Derived Class, Single Inheritance, Multiple, Hierarchical, Multilevel and Hybrid Inheritance, Visibility Mode, Containership, Overriding of function in inheritance, Virtual Base Class

Data File Handling

File, Stream, Text file, Binary file, ofstream, ifstream, fstream class, Opening a file, Closing file, Input and output operation, File pointer and their manipulation

Text & Binary File

Program to write, read, display, count number of characters, words,lines in text file. In binary file write, display records, search, delete and modify a record

Pointer

C++ Memory Map, Defining Pointer Variable, Pointer Arithmetics, Pointers and Arrays, Pointers and strings, Pointers to Structures, Dynamic memory, Memory Leak, Self Referential Structure

Static Stack

Stack as an Array, Defining member function PUSH() - to push data to the stack, POP() - to remove data from the stack.

Circular Queue

Array implemented circular queue containing data values, function to insert and delete data from the queue

Dynamic Stack

Defining structure of node for the linked stack, Defining member function PUSH() - to push a node to the stack which is allocated dynamically, POP() - to remove a node from the stack and release the memory.

Dynamic Queue

linked list implemented queue containing data values, function to insert and delete a number from the queue

Getting Started

A computer cannot understand our language that we use in our day to day conversations, and likewise, we cannot understand the binary language that the computer uses to do it’s tasks. It is therefore necessary for us to write instructions in some specially defined language like C++ which is like natural language and after converting with the help of compiler the computer can understand it.

C++ Compiler

A C++ compiler is itself a computer program which’s only job is to convert the C++ program from our form to a form the computer can read and execute. The original C++ program is called the “source code”, and the resulting compiled code produced by the compiler is usually called an “object file”.

Before compilation the preprocessor performs preliminary operations on C++ source files. Preprocessed form of the source code is sent to compiler.

After compilation stage object files are combined with predefined libraries by alinker, sometimes called a binder, to produce the final complete file that can be executed by the computer. A library is a collection of pre-compiled “object code” that provides operations that are done repeatedly by many computer programs.

Using Turbo C++ Compiler

The first and frequently used method for creating program is Turbo

1. Now type sample program on Editor
2. Click on Compile menu choose Compile option or press Alt+F9
3. Click on Run menu choose Run option or press Ctrl+F9
4. If there is no error output will be displayed on User Screen

Before we begin to learn to write meaningful programs in C++ language, let us have a look at the various buliding block of C++ language, also called elements of C++ language....

C++ Basics

C++ Character Set

Character set is a set of valid characters that a language can recognize.

Letters	A-Z, a-z
Digits	0-9
Special Characters	Space + - * / ^ \ () [] {} = != <> ‘ “ $ , ; : % ! & ? _ # <= >= @
Formatting characters	backspace, horizontal tab, vertical tab, form feed, and carriage return

Tokens

A token is a group of characters that logically belong together. The programmer can write a program by using tokens. C++ uses the following types of tokens.
Keywords, Identifiers, Literals, Punctuators, Operators.

1. Keywords

These are some reserved words in C++ which have predefined meaning to compiler called keywords. Some commonly used Keyword are given below:

asm	auto	break	case	catch
char	class	const	continue	default
delete	do	double	else	enum
extern	inline	int	float	for
friend	goto	if	long	new
operator	private	protected	public	register
return	short	signed	sizeof	static
struct	switch	template	this	Try
typedef	union	unsigned	virtual	void
volatile	while

2. Identifiers

Symbolic names can be used in C++ for various data items used by a programmer in his program. A symbolic name is generally known as an identifier. The identifier is a sequence of characters taken from C++ character set. The rule for the formation of an identifier are:

· An identifier can consist of alphabets, digits and/or underscores.

· It must not start with a digit

· C++ is case sensitive that is upper case and lower case letters are considered different from each other.

· It should not be a reserved word.

3. Literals

Literals (often referred to as constants) are data items that never change their value during the execution of the program. The following types of literals are available in C++.

· Integer-Constants

· Character-constants

· Floating-constants

· Strings-constants

Integer Constants

Integer constants are whole number without any fractional part. C++ allows three types of integer constants.
Decimal integer constants : It consists of sequence of digits and should not begin with 0 (zero). For example 124, - 179, +108.
Octal integer constants: It consists of sequence of digits starting with 0 (zero). For example. 014, 012.
Hexadecimal integer constant: It consists of sequence of digits preceded by ox or OX.

Character constants

A character constant in C++ must contain one or more characters and must be enclosed in single quotation marks. For example 'A', '9', etc. C++ allows nongraphic characters which cannot be typed directly from keyboard, e.g., backspace, tab, carriage return etc. These characters can be represented by using an escape sequence. An escape sequence represents a single character. The following table gives a listing of common escape sequences.

Escape Sequence	Nongraphic Character
\a	Bell (beep)
\n	Newline
\r	Carriage Return
\t	Horizontal tab
\0	Null Character

Floating constants

They are also called real constants. They are numbers having fractional parts. They may be written in fractional form or exponent form. A real constant in fractional form consists of signed or unsigned digits including a decimal point between digits. For example 3.0, -17.0, -0.627 etc.

String Literals

A sequence of character enclosed within double quotes is called a string literal. String literal is by default (automatically) added with a special character ‘\0' which denotes the end of the string. Therefore the size of the string is increased by one character. For example "COMPUTER" will re represented as "COMPUTER\0" in the memory and its size is 9 characters.

4. Punctuators

The following characters are used as punctuators in C++.

Brackets [ ]	Opening and closing brackets indicate single and multidimensional array subscript.
Parentheses ( )	Opening and closing brackets indicate functions calls,; function parameters for grouping expressions etc.
Braces { }	Opening and closing braces indicate the start and end of a compound statement.
Comma ,	It is used as a separator in a function argument list.
Semicolon ;	It is used as a statement terminator.
Colon :	It indicates a labeled statement or conditional operator symbol.
Asterisk *	It is used in pointer declaration or as multiplication operator.
Equal sign =	It is used as an assignment operator.
Pound sign #	It is used as pre-processor directive.

5. Operators

Operators are special symbols used for specific purposes. C++ provides six types of operators. Arithmetical operators, Relational operators, Logical operators, Unary operators, Assignment operators, Conditional operators, Comma operator

Data Handling

Basic Data Types

C++ supports a large number of data types. The built in or basic data types supported by C++ are integer, floating point and character. These are summarized in table along with description and memory requirement

Type	Byte	Range	Description
int	2	-32768 to +32767	Small whole number
long int	4	-2147483648 to +2147483647	Large whole number
float	4	3.4x10-38 to 3.4x10+38	Small real number
double	8	1.7x10-308 to 1.7x10+308	Large real number
long double	10	3.4x10-4932 to 3.4x10+4932	Very Large real number
char	1	0 to 255	A Single Character

Variables

It is a location in the computer memory which can store data and is given a symbolic name for easy reference. The variables can be used to hold different values at different times during the execution of a program.

To understand more clearly we should study the following statements:
Total = 20.00; In this statement a value 20.00 has been stored in a memory location Total.

Declaration of a variable

Before a variable is used in a program, we must declare it. This activity enables the compiler to make available the appropriate type of location in the memory.
float Total;

You can declare more than one variable of same type in a single single statement
int x,y;

Initialization of variable

When we declare a variable it's default value is undetermined. We can declare a variable with some initial value.
int a = 20;

Input/Output (I/O)

C++ supports input/output statements which can be used to feed new data into the computer or obtain output on an output device such as: VDU, printer etc. The following C++ stream objects can be used for the input/output purpose.

cin console input
cout console output

cout is used in conjuction with << operator, known as insertion or put to operator.
cin is used in conjuction with >> operator, known as extraction or get from operator.

cout << “My first computer";
Once the above statement is carried out by the computer, the message "My first computer" will appear on the screen.

cin can be used to input a value entered by the user from the keyboard. However, the get from operator>> is also required to get the typed value from cin and store it in the memory location.
Let us consider the following program segment:
int marks;
cin >> marks;
In the above segment, the user has defined a variable marks of integer type in the first statement and in the second statement he is trying to read a value from the keyboard.

Type Conversion

The process in which one pre-defined type of expression is converted into another type is called conversion. There are two types of conversion in C++.

1. Implicit conversion
2. Explicit conversion

Implicit conversion
Data type can be mixed in the expression. For example
double a;
int b = 5;
float c = 8.5;
a = b * c;

When two operands of different type are encountered in the same expression, the lower type variable is converted to the higher type variable. The following table shows the order of data types.

Order of data types
Data type long double double float long int char	order (highest) To (lowest)

The int value of b is converted to type float and stored in a temporary variable before being multiplied by the float variable c. The result is then converted to double so that it can be assigned to the double variable a.

Explicit conversion
It is also called type casting. It temporarily changes a variable data type from its declared data type to a new one. It may be noted here that type casting can only be done on the right hand side the assignment statement.
T_Pay = double (salary) + bonus;
Initially variable salary is defined as float but for the above calculation it is first converted to double data type and then added to the variable bonus.

Constants

A number which does not change its value during execution of a program is known as a constant. Any attempt to change the value of a constant will result in an error message. A constant in C++ can be of any of the basic data types, const qualifier can be used to declare constant as shown below:
const float pi = 3.1415;
The above declaration means that Pi is a constant of float types having a value 3.1415.
Examples of valid constant declarations are:
const int rate = 50;
const float pi = 3.1415;
const char ch = 'A';

Operators

Operators are special symbols used for specific purposes. C++ provides six types of operators.
Arithmetical operators, Relational operators, Logical operators, Unary operators, Assignment operators, Conditional operators, Comma operator

Arithmetical operators

Arithmetical operators +, -, *, /, and % are used to performs an arithmetic (numeric) operation. You can use the operators +, -, *, and / with both integral and floating-point data types. Modulus or remainder % operator is used only with the integral data type.
Operators that have two operands are called binary operators.

Relational operators

The relational operators are used to test the relation between two values. All relational operators are binary operators and therefore require two operands. A relational expression returns zero when the relation is false and a non-zero when it is true. The following table shows the relational operators.

Relational Operators	Meaning
<	Less than
<=	Less than or equal to
==	Equal to
>	Greater than
>=	Greater than or equal to
! =	Not equal to

Logical operators

The logical operators are used to combine one or more relational expression. The logical operators are

Operators	Meaning
\|\|	OR
&&	AND
!	NOT

Unary operators

C++ provides two unary operators for which only one variable is required.
For Example a = - 50;
a = + 50; Here plus sign (+) and minus sign (-) are unary because they are not used between two variables.

Assignment operator

The assignment operator '=' is used for assigning a variable to a value. This operator takes the expression on its right-hand-side and places it into the variable on its left-hand-side. For example: m = 5; The operator takes the expression on the right, 5, and stores it in the variable on the left, m. x = y = z = 32; This code stores the value 32 in each of the three variables x, y, and z.

in addition to standard assignment operator shown above, C++ also support compound assignment operators.

Compound Assignment Operators

Operator	Example	Equivalent to
+ =	A + = 2	A = A + 2
- =	A - = 2	A = A - 2
% =	A % = 2	A = A % 2
/=	A/ = 2	A = A / 2
*=	A * = 2	A = A * 2

Increment and Decrement Operators

C++ provides two special operators viz '++' and '--' for incrementing and decrementing the value of a variable by 1. The increment/decrement operator can be used with any type of variable but it cannot be used with any constant. Increment and decrement operators each have two forms, pre and post.

The syntax of the increment operator is:
Pre-increment: ++variable
Post-increment: variable++
The syntax of the decrement operator is:
Pre-decrement: ––variable
Post-decrement: variable––

In Prefix form first variable is first incremented/decremented, then evaluated
In Postfix form first variable is first evaluated, then incremented/decremented

int x,y;
int i=10,j=10;
x = ++i;     //add one to i, store the result back in x
y= j++;     //store the value of j to y then add one to j
cout<<x;    //11
cout<<y;   //10

Conditional operator

The conditional operator ?: is called ternary operator as it requires three operands. The format of the conditional operator is:
Conditional_ expression ? expression1 : expression2;
If the value of conditional expression is true then the expression1 is evaluated, otherwise expression2 is evaluated. int a = 5, b = 6;
big = (a > b) ? a : b; The condition evaluates to false, therefore biggets the value from b and it becomes 6.

The comma operator

The comma operator gives left to right evaluation of expressions. When the set of expressions has to be evaluated for a value, only the rightmost expression is considered.
int a=1, b=2, c=3, i; // comma acts as separator, not as an operator
i = (a, b); // stores b into i Would first assign the value of a to i, and then assign value of b to variable i. So, at the end, variable i would contain the value 2.

The sizeof operator

As we know that different types of Variables, constant, etc. require different amounts of memory to store them The sizeof operator can be used to find how many bytes are required for an object to store in memory. For example
sizeof (char) returns 1
sizeof (int) returns 2
sizeof (float) returns 4
If k is integer variable, the sizeof (k) returns 2.
the sizeof operator determines the amount of memory required for an object at compile time rather than at run time.

The order of Precedence

The order in which the Arithmetic operators (+,-,*,/,%) are used in a. given expression is called the order of precedence. The following table shows the order of precedence.

Order	Operators
First Second Third	() *, /, % +, -

The following table shows the precedence of operators.

++, --(post increment/decrement)	Highest To Lowest
++ (Pre increment) -- (Pre decrement), sizeof ( ), !(not), -(unary), +(unary)
*,/, %
+, -
<, <=, >, >=
==,!=
&&
? :
=
Comma operator

Flow Of Control

Statements

Statements are the instructions given to the computer to perform any kind of action. Action may be in the form of data movement, decision making etc. Statements form the smallest executable unit within a C++ program. Statements are always terminated by semicolon.

Compound Statement

A compound statement is a grouping of statements in which each individual statement ends with a semi-colon. The group of statements is called block. Compound statements are enclosed between the pair of braces ({}.). The opening brace ({) signifies the beginning and closing brace (}) signifies the end of the block.

Null Statement

Writing only a semicolon indicates a null statement. Thus ';' is a null or empty statement. This is quite useful when the syntax of the language needs to specify a statement but the logic of the program does not need any statement. This statement is generally used in for and while looping statements.

Conditional Statements

Sometimes the program needs to be executed depending upon a particular condition. C++ provides the following statements for implementing the selection control structure.

· if statement

· if else statement

· nested if statement

· switch statement

if statement

syntax of the if statement

if (condition)
{
statement(s);
}

From the flowchart it is clear that if the if condition is true, statement is executed; otherwise it is skipped. The statement may either be a single or compound statement.

if else statement

syntax of the if - else statement

if (condition)
statement1;
else
statement2;

From the above flowchart it is clear that the given condition is evaluated first. If the condition is true, statement1 is executed. If the condition is false, statement2 is executed. It should be kept in mind that statement and statement2 can be single or compound statement.

if example	if else example
if (x == 100) cout << "x is 100";	if (x == 100) cout << "x is 100"; else cout << "x is not 100";

Nested if statement

The if block may be nested in another if or else block. This is called nesting of if or else block.

syntax of the nested if statement

if(condition 1)
{
if(condition 2)
{
statement(s);
}
}

if(condition 1)
statement 1;
else if (condition 2)
statement2;
else
statement3;

if-else-if example

if(percentage>=60)
     cout<<"Ist division";
else if(percentage>=50)
     cout<<"IInd division";
else if(percentage>=40)
     cout<<"IIIrd division";
else
     cout<<"Fail" ;

switch statement

The if and if-else statements permit two way branching whereas switch statement permits multiple branching. The syntax of switch statement is:

switch (var / expression)
{
   case constant1 : statement 1;
   break;
   case constant2 : statement2;
   break;
.
   .
   default: statement3;
   break;
}

The execution of switch statement begins with the evaluation of expression. If the value of expression matches with the constant then the statements following this statement execute sequentially till it executes break. The break statement transfers control to the end of the switch statement. If the value of expression does not match with any constant, the statement with default is executed.

Some important points about switch statement

· The expression of switch statement must be of type integer or character type.

· The default case need not to be used at last case. It can be placed at any place.

· The case values need not to be in specific order.

Library Function

# Include Directive
The # include directive instructs the compiler to read and include another file in the current file. The compiler compiles the entire code. A header file may be included in one of two ways.

include <iostream.h>
or
include "iostream.h"

The header file in angle brackets Â means that file reside in standard include directory. The header file in double quotes means that file reside in current directory.

LIBRARY FUNCTION
C++ provides many built in functions that saves the programming time

Mathematical Functions
Some of the important mathematical functions in header file math.h are

Function	Meaning
sin(x)	Sine of an angle x (measured in radians)
cos(x)	Cosine of an angle x (measured in radians)
tan(x)	Tangent of an angle x (measured in radians)
asin(x)	Sin-1 (x) where x (measured in radians)
acos(x)	Cos-1 (x) where x (measured in radians)
exp(x)	Exponential function of x (ex)
log(x)	logarithm of x
log 10(x)	Logarithm of number x to the base 10
sqrt(x)	Square root of x
pow(x, y)	x raised to the power y
abs(x)	Absolute value of integer number x
fabs(x)	Absolute value of real number x

Character Functions
All the character functions require ctype.h header file. The following table lists the function.

Function	Meaning
isalpha(c)	It returns True if C is an uppercase letter and False if c is lowercase.
isdigit(c)	It returns True if c is a digit (0 through 9) otherwise False.
isalnum(c)	It returns True if c is a digit from 0 through 9 or an alphabetic character (either uppercase or lowercase) otherwise False.
islower(c)	It returns True if C is a lowercase letter otherwise False.
isupper(c)	It returns True if C is an uppercase letter otherwise False.
toupper(c)	It converts c to uppercase letter.
tolower(c)	It converts c to lowercase letter.

String FunctionsThe string functions are present in the string.h header file. Some string functions are given below:

strlen(S)	It gives the no. of characters including spaces present in a string S.
strcat(S1, S2)	It concatenates the string S2 onto the end of the string S1. The string S1 must have enough locations to hold S2.
strcpy(S1, S2)	It copies character string S2 to string S1. The S1 must have enough storage locations to hold S2.
strcmp((S1, S2)==0) strcmp((S1, S2)>0) strcmp((S1, S2) <0)	It compares S1 and S2 and finds out whether S1 equal to S2, S1 greater than S2 or S1 less than S2.
strcmpi((S1, S2)==0) strcmpi((S1, S2)>0) strcmpi((S1, S2) <0)	It compares S1 and S2 ignoring case and finds out whether S1 equal to S2, S1 greater than S2 or S1 less than S2.
strrev(s)	It converts a string s into its reverse
strupr(s)	It converts a string s into upper case
strlwr(s)	It converts a string s into lower case

Console I/O functions

The following are the list of functions are in stdio.h

getchar()	It returns a single character from a standard input device (keyboard). It takes no parameter and the returned value is the input character.
putchar()	It takes one argument, which is the character to be sent to output device. It also returns this character as a result.
gets()	It gets a string terminated by a newline character from the standard input stream stdin.
puts()	It takes a string which is to be sent to output device.

General purpose standard library functions

The following are the list of functions are in stdlib.h

randomize()	It initializes / seeds the random number generator with a random number
random(n)	It generates a random number between o to n-1
atoi(s)	It converts string s into a numerical representation.
itoa(n)	It converts a number to a string

Some More Functions

The getch() and getche() functions
The general for of the getch() and getche() is
ch=getche();
ch1=getch();
ch and ch1 are the variables of type character. They take no argument and require the conio.h header file. On execution, the cursor blinks, the user must type a character and press enter key. The value of the character returned from getche() is assigned to ch. The getche() fuction echoes the character to the screen. Another function, getch(), is similar to getche() but does not echo character to the screen.

Function

A function is a subprogram that acts on data and often returns a value. A program written with numerous functions is easier to maintain, update and debug than one very long program. By programming in a modular (functional) fashion, several programmers can work independently on separate functions which can be assembled at a later date to create the entire project. Each function has its own name. When that name is encountered in a program, the execution of the program branches to the body of that function. When the function is finished, execution returns to the area of the program code from which it was called, and the program continues on to the next line of code.

Creating User-Defined Functions

Declare the function.

The declaration, called the FUNCTION PROTOTYPE, informs the compiler about the functions to be used in a program, the argument they take and the type of value they return.

Define the function.

The function definition tells the compiler what task the function will be performing. The function prototype and the function definition must be same on the return type, the name, and the parameters. The only difference between the function prototype and the function header is a semicolon.
The function definition consists of the function header and its body. The header is EXACTLY like the function prototype, EXCEPT that it contains NO terminating semicolon.

//Prototyping, defining and calling a function
#include <iostream.h>
void starline();         // prototype the function
int main()
{
     starline( );      // function call
     cout<< "\t\tBjarne Stroustrup\n";
     starline( );    // function call
     return 0;
}
// function definition
void starline()
{
     int count;         // declaring a LOCAL variable
     for(count = 1; count <=65; count++)
          cout<< "*";
     cout<<endl;
}

Argument To A Function

Sometimes the calling function supplies some values to the called function. These are known as parameters. The variables which supply the values to a calling function called actual parameters. The variable which receive the value from called statement are termed formal parameters.

Consider the following example that evaluates the area of a circle.

#include<iostream.h>
void area(float);
int main()
{
   float radius;
    cin>>radius;
    area(radius);
    return 0;
}
void area(float r)
{
    cout<< “the area of the circle is”<<3.14*r*r<<”\n”;
}

Here radius is called actual parameter and r is called formal parameter.

Return Type Of A Function

// Example program

#include <iostream.h>
int timesTwo(int num);   // function prototype
int main()
{
     int number, response;
     cout<<"Please enter a number:";
     cin>>number;
     response = timesTwo(number); //function call
     cout<< "The answer is "<<response;
     return 0;
}
//timesTwo function
int timesTwo (int num)
{
     int answer;   //local variable
     answer = 2 * num;
     return (answer);
}

Calling Of A Function

the function can be called using either of the following methods:
i) call by value
ii) call by reference

Call By Value

In call by value method, the called function creates its own copies of original values sent to it. Any changes, that are made, occur on the function’s copy of values and are not reflected back to the calling function.

Call By Reference

In call be reference method, the called function accesses and works with the original values using their references. Any changes, that occur, take place on the original values are reflected back to the calling code.

Consider the following program which will swap the value of two variables.

using call by reference	using call by value
#include<iostream.h> void swap(int &, int &); int main() { int a=10,b=20; swap(a,b); cout<<a<<" "<<b; return 0; } void swap(int &c, int &d) { int t; t=c; c=d; d=t; }	#include<iostream.h> void swap(int , int ); int main() { int a=10,b=20; swap(a,b); cout<<a<<" "<< b; return 0; } void swap(int c, int d) { int t; t=c; c=d; d=t; }
output: 20 10	output: 10 20

Function With Default Arguments

C++ allows to call a function without specifying all its arguments. In such cases, the function assigns a default value to a parameter which does not have a mathching arguments in the function call. Default values are specified when the function is declared. The complier knows from the prototype how many arguments a function uses for calling.
Example :
float result(int marks1, int marks2, int marks3=75);
a subsequent function call
average = result(60,70);
passes the value 60 to marks1, 70 to marks2 and lets the function use default value of 75 for marks3.
The function call
average = result(60,70,80);
passes the value 80 to marks3.

Inline Function

Functions save memory space because all the calls to the function cause the same code to be executed. The functions body need not be duplicated in memory. When the complier sees a function call, it normally jumps to the function. At the end of the function. it normally jumps back to the statement following the call.
While the sequence of events may save memory space, it takes some extra time. To save execution time in short functions, inline function is used. Each time there is a function call, the actual code from the function is inserted instead of a jump to the function. The inline function is used only for shorter code.
inline int cube(int r)
{
return r*r*r;
}

Some important points to be noted

· Function is made inline by putting a word inline in the beginning.

· Inline function should be declared before main() function.

· It does not have function prototype.

· Only shorter code is used in inline function If longer code is made inline then compiler ignores the request and it will be executed as normal function.

Global Variable And Local Variable

Local Variable : a variable declared within the body of a function will be evaluated only within the function. The portion of the program in which a variable is retained in memory is known as the scope of the variable. The scope of the local variable is a function where it is defined. A variable may be local to function or compound statement.
Global Variable : a variable that is declared outside any function is known as a global variable. The scope of such a variable extends till the end of the program. these variables are available to all functions which follow their declaration. So it should be defined at the beginning, before any function is defined.

Variables and storage Class

The storage class of a variable determines which parts of a program can access it and how long it stays in existence. The storage class can be classified as automatic register static external
Automatic variable
All variables by default are auto i.e. the declarations int a and auto int a are equivalent. Auto variables retain their scope till the end of the function in which they are defined. An automatic variable is not created until the function in which it defined is called. When the function exits and control is returned to the calling program, the variables are destroyed and their values are lost. The name automatic is used because the variables are automatically created when a function is called and automatically destroyed when it returns.
Register variable
A register declaration is an auto declaration. A register variable has all the characteristics of an auto variable. The difference is that register variable provides fast access as they are stored inside CPU registers rather than in memory.
Static variable
A static variable has the visibility of a local variable but the lifetime of an external variable. Thus it is visible only inside the function in which it is defined, but it remains in existence for the life of the program.
External variable
A large program may be written by a number of persons in different files. A variable declared global in one file will not be available to a function in another file. Such a variable, if required by functions in both the files, should be declared global in one file and at the same time declared external in the second file.

Array

An array is a collection of data elements of same data type. It is described by a single name and each element of an array is referenced by using array name and its subscript no.

Declaration of Array

Type arrayName[numberOfElements];

For example, int Age[5] ;
float cost[30];

Initialization of One Dimensional Array

An array can be initialized along with declaration. For array initialization it is required to place the elements separated by commas enclosed within braces. int A[5] = {11,2,23,4,15}; It is possible to leave the array size open. The compiler will count the array size. int B[] = {6,7,8,9,15,12};

Referring to Array Elements

In any point of a program in which an array is visible, we can access the value of any of its elements individually as if it was a normal variable, thus being able to both read and modify its value. The format is as simple as:
name[index]

Examples:
cout<<age[4];    //print an array element
age[4]=55;         // assign value to an array element
cin>>age[4];       //input element 4

Using Loop to input an Array from user

int age [10], i ;
for (i=0 ; i<10; i++)
{
cin>>age[i];
}

Arrays as Parameters

At some moment we may need to pass an array to a function as a parameter. In C++ it is not possible to pass a complete block of memory by value as a parameter to a function, but we are allowed to pass its address.
For example, the following function: void print(int A[]) accepts a parameter of type "array of int" called A.
In order to pass to this function an array declared as: int arr[20]; we need to write a call like this:
print(arr);
Here is a complete example:

#include <iostream.h>
void print(int A[], int length)
{
for (int n=0; n<length; n++)
cout << A[n] << " ";
cout << "\n";
}

int main ()
{
int arr[] = {5, 10, 15};
print(arr,3);
return 0;
}

Basic Operation On One Dimensional Array

Function to traverse the array A

void display(int A[], int n)
{
       cout<<"The elements of the array are:\n";
       for(int i=0;i<n;i++)
              cout<<A[i];
}

Function to Read elements of the array A

void Input(int A[], int n)
{
      cout<<"Enter the elements:";
      for(int i=0;i<n;i++)
            cin>>A[i];
}

Function to Search for an element from A by Linear Search

int Lsearch(int A[], int n, int Data)
{
      int I;
      for(I=0; I<n; I++)
      {
            if(A[I]==Data)
            {
                  cout<<"Data Found at : "<<I;
                  return;
            }
      }
      cout<<"Data Not Found in the array"<<endl;
}

Function to Search for an element from Array A by Binary Search

int BsearchAsc(int A[], int n, int data)
{
       int Mid,Lbound=0,Ubound=n-1,Found=0;
       while((Lbound<=Ubound) && !(Found))
       {
              Mid=(Lbound+Ubound)/2;        //Searching The Item
              if(data>A[Mid])
                     Lbound=Mid+1;
              else if(data<A[Mid])
                     Ubound=Mid-1;
              else
                     Found++;
       }
       if(Found)
              return(Mid+1);        //returning 1ocation, if present
       else
              return(-1);        //returning -1,if not present
}

Function to Sort the array A by Bubble Sort

void BSort(int A[], int n)
{
    int I,J,Temp;
    for(I=0;I<n-1;I++) //sorting
   {
       for(J=0;J<(n-1-I);J++)
            if(A[J]>A[J+1])
           {
               Temp=A[J]; //swapping
               A[J]=A[J+1];
               A[J+1]=Temp;
           }
    }
}

Function to Sort the array ARR by Insertion Sort

void ISort(int A[], int n)
{
       int I,J,Temp;
       for(I=1;I<n;I++) //sorting
       {
           Temp=A[I];
           J=I-1;
           while((Temp<A[J]) && (J>=0))
           {
               A[J+1]=A[J];
               J--;
           }
           A[J+1]=Temp;
       }
}

Function to Sort the array by Selection Sort

void SSort(int A[], int n)
{
    int I,J,Temp,Small;
    for(I=0;I<n-1;I++)
    {
         Small=I;
         for(J=I+1;J<n;J++) //finding the smallest element
         if(A[J]<A[Small])
              Small=J;
         if(Small!=I)
        {
            Temp=A[I]; //Swapping
            A[I]=A[Small];
            A[Small]=Temp;
        }
     }
}

Function to merge A and B arrays of lenghts N and M

void Merge(int A[], int B[], int C[], int N, int M, int &K)
{
      int I=0, J=0;
      K=0;             //Initialisation of counters for A, B, and C
      while (I<N && J<M)
      {
            if (A[I]<B[J])
                  C[K++]=A[I++];
            else if (A[I]>B[J])
                  C[K++]=B[J++];
            else
            {
                  C[K++]=A[I++];
                  J++;
            }
      }
      for (int T=I;T<N;T++)
            C[K++]=A[T];
      for (T=J;T<M;T++)
            C[K++]=B[T];
}

C-STRINGS (Character Arrays)

STRING: It is an array of type char.

Syntax for declaration

char <array/string name> [max. number of characters to be stored +1];

The number of elements that can be stored in a string is always n-1, if the size of the array specified is n. This is because 1 byte is reserved for the NULL character '\0' i.e. backslash zero. A string is always terminated with the NULL character.

Example: char str[80]; In the above example, str can be used to store a string with 79 characters.

Initializing a string

A string can be initialized to a constant value when it is declared.

char str[ ] = "Good"; Or char str[]={'G','o','o','d','\0'};

Here. 'G' will be stored in str[0], 'o' in str[1] and so on.

Note: When the value is assigned to the complete string at once, the computer automatically inserts the NULL character at the end of the string. But, if it is done character by character, then we have to insert it at the end of the string.

Reading strings with/without embedded blanks

To read a string without blanks cin can be used cin>>str; To read a string with blanks cin.getline() or gets() can be used. cin.getline(str,80); -Or- gets(str);

Printing strings

cout and puts() can be used to print a string. cout<<str: Or
puts(str);

Note: For gets( ) and puts(), the header file stdio.h has to be included. puts() can be used to display only strings. It takes a line feed after printing the string.

cin	gets()
It can be used to take input of a value of any data type.	It can be used to take input of a string.
It takes the white space i.e. a blank, a tab, or a new line character as a string terminator.	It does not take the white space i.e. a blank, a tab, or a new line character, as a string terminator.
It requires header file iostream.h	It requires the header file stdio.h
Example: char S[80]; cout<<"Enter a string:”; cin>>S;	Example: char S[80]; cout<<"Enter a string:"; gets(S);

cout	puts()
It can be used to display the value of any data type.	It can be used to display the value of a string.
It does not take a line feed after displaying the string.	It takes a line feed after displaying the string.
It requires the header file iostream.h	It requires the header file stdio.h
Example: char S[80]="Computers"; cout<<S<<S; Output: ComputersComputers	Example: char S[80]="Computers"; puts(S); puts(S); Output: Computers Computers

Counting the number of characters in a string and printing it backwards

#include<iostream.h>
#include<stdio.h>
int main( )
{
  char str[80];
  cout<<"Enter a string:";
  gets(str);
  for(int l=0; str[l]!='\0';l++);  //Loop to find length
    cout<<"The length of the string is : "<<l<<endl ;
  for(int i=l-1;i>=0;i--)    //Loop to display the string backwards
    cout<<str[i];
  return 0;
}

Function to count the number of words in a string

void count(char S[])
{
int words=0;
for(int i=0;S[i]!='\0';i++)
{
if (S[i]==' ')
words++; //Checking for spaces
}
cout<<"The number of words="<<words+1<<endl;
}

Function to find the length of a string

int length(char S[ ])
{
for(int i=0;S[i]!='\0';i++);
return i;
}

Function to copy the contents of string S2 to S1

void copy(char S1[ ], char S2[ ])
{
   for(int i=0;S2[i]!='\0';i++)
      S1[i]=S2[i];
   S1[i]='\0';
}

Function to concatenate the contents of string S2 to S1

void concat(char S1[ ], char S2[ ])
{
   for(int l=0;S1[l]!='\0';l++);
     for(int i=0;S2[i]!='\0';i++)
         S1[l++]=S2[i];
    S1[l]='\0';
}

Function to compare strings STR1 to STR2. The function returns a value>0 if //STR1>STR2, a value<0 if STR1<STR2, and value 0 if STR1=STR2

int compare(char STR1[ ],char STR2[])
{
for(int I=0;STR1[I]==STR2[I] && STR1[I]!='\0'&&STR2[I]!='\0'; I++);
return STR1[I]-STR2[I];
}

To reverse the contents of string S and store it in string Rev

void Reverse(char S[], char Rev[])
{
   for(int C1=0; S[C1]!='\0'; C1++);
      C1--;
   for(int C2=0;C1>=0;C2++,C1--)
      Rev[C2]=S[C1];
   Rev[C2]='\0';
}

Function to check whether a string S is a palindrome or not

int Palin(char S[])
{
   for(int L=0;S[L]!='\0';L++);    //To find length
      for(int C=0;(C<L/2) && (S[C]==S[L-C-1]);C++);
         return (C==L/2)?1:0; //Returns 1 if Palindrome else 0
}

Function to change the case of string S to uppercase

void Upper(char S[])
{
for(int i=0;S[i]!='\0';i++)
S[i] = (S[i]>='a' && S[i]<='z')?(S[i]-32):S[i];
}

Function to change the case of string S to lower case

void Lower(char S[])
{
for(int i=0;S[i]!='\0';i++)
S[i] = (S[i]>='A' && S[i]<='Z')?(S[i]+32):S[i];
}

Function to extract n characters from left side of the string and store it in a different string. Example: 4 characters from ENVIRONMENT=ENVI

int SLeft(char S[ ], int n, char result[ ])
{
   for(int l=0;S[l]!='\0';l++);
     if(n<=I)    //characters extracted should be <=length
     {
        for(int i=0;i<n;i++)
            result[i]=S[i];
        result[i]='\0';
        return 1;
     }
     else
        return 0;
}

Function to extract n characters from right side of the string and store it in a different string. Example: 4 characters from ENVIRONMENT=MENT

int SRight(char S[ ], int n, char result[ ])
{
   for(int l=0;S[l]!='\0';l++);
     if(n<=I)     //characters extracted should be <=length
     {
        for(int j=0;i=l-n;S[i]!=’/0’;i++,j++)
            result[j]=S[i];
       result[j]='\0';
       return 1;
    }
     else
        return 0;
}

Function to extract n characters from specified location loc of the string and store it in a different string. Example: 4 characters from third location in string ENVIRONMENT= VIRO

int substring(char S[ ], int n, int loc, char result[ ])
{
  for(int l=0;S[l]!='\0';l++);
     if(n<=I)      //characters extracted should be <=length
     {
       for(int j=0;i=l-n;S[i]!=’/0’;i++,j++)
           result[j]=S[i];
        result[j]='\0';
       return 1;
     }
     else
        return 0;
}

Two Dimensional Array

It is a collection of data elements of same data type arranged in rows and columns (that is, in two dimensions).

Declaration of Two-Dimensional Array

Type arrayName[numberOfRows][numberOfColumn];

For example, int Sales[3][5];

Initialization of Two-Dimensional Array

An two-dimensional array can be initialized along with declaration. For two-dimensional array initialization, elements of each row are enclosed within curly braces and separated
by commas. All rows are enclosed within curly braces. int A[4][3] = {{22, 23, 10},
              {15, 25, 13},
              {20, 74, 67},
              {11, 18, 14}};

Referring to Array Elements

To access the elements of a two-dimensional array, we need a pair of indices: one for
the row position and one for the column position. The format is as simple as:
name[rowIndex][columnIndex]

Examples: cout<<A[1][2];    //print an array element
A[1][2]=13;         // assign value to an array element
cin>>A[1][2];       //input element

Using Loop to input an Two-Dimensional Array from user

int mat[3][5], row, col ;
for (row = 0; row < 3; row++)
for (col = 0; col < 5; col++)
cin >> mat[row][col];

Arrays as Parameters

Two-dimensional arrays can be passed as parameters to a function, and they are passed by reference. When declaring a two-dimensional array as a formal parameter, we can omit the size of the first dimension, but not the second; that is, we must specify the number of columns. For example: void print(int A[][3],int N, int M) In order to pass to this function an array declared as: int arr[4][3]; we need to write a call like this: print(arr);
Here is a complete example:

#include <iostream.h>
void print(int A[][3],int N, int M)
{
for (R = 0; R < N; R++)
for (C = 0; C < M; C++)
cin >> A[R][C];
}

int main ()
{
int arr[4][3] ={{12, 29, 11},
                  {25, 25, 13},
                  {24, 64, 67},
                  {11, 18, 14}};
print(arr,4,3);
return 0;
}

Function to read the array A

void Read(int A[][20], int N, int M)
{
  for(int R=0;R<N;R++)
    for(int C=0;C<M;C++)
    {
      cout<<"(R<<','<<")?";
      cin>>A[R][C];
     }
}

Function to display content of a two dimensional array A

void Display(int A[][20],int N, int M)
{
  for(int R=0;R<N;R++)
  {
     for(int C=0;C<M;C++)
        cout<<setw(10)<<A[R][C];
     cout<<endl;
   }
}

Function to find the sum of two dimensional arrays A and B

void Addition(int A[][20], int B[][20],int N, int M)
{
  for(int R=0;R<N;R++)
    for(int C=0;C<M;C++)
      C[R][C]=A[R][C]+B[R][C];
}

Function to multiply two dimensional arrays A and B of order NxL and LxM

void Multiply(int A[][20], int B[][20], int C[][20],int N, int L, int M)
{
  for(int R=0;R<N;R++)
   for(int C=0;C<M;C++)
   {
      C[R][C]=0;
      for(int T=0;T<L;T++)
        C[R][C]+=A[R][T]*B[T][C];
    }
}

Function to find & display sum of rows & sum of cols. of a 2 dim. array A

void SumRowCol(int A[][20], int N, int M)
{
  for(int R=0;R<N;R++)
  {
     int SumR=0;
     for(int C=0;C<M;C++)
       SumR+=A[R][C];
     cout<<"Row("<<R<<")="<<SumR<<endl;
   }
  for(int R=0;R<N;R++)
  {
    int SumR=0;
    for(int C=0;C<M;C++)
      SumR+=A[R][C];
    cout<<"Row("<<R<<")="<<SumR<<endl;
   }
}

Function to find sum of diagonal elements of a square matrix A

void Diagonal(int A[][20], int N, int &Rdiag, int &LDiag)
{
  for(int I=0,Rdiag=0;I<N;I++)
    Rdiag+=A[I][I];
  for(int I=0,Ldiag=0;I<N;I++)
    Ldiag+=A[N-I-1][I];
}

Function to find out transpose of a two dimensional array A

void Transpose(int A[][20], int B[][20],int N, int M)
{
  for(int R=0;R<N;R++)
    for(int C=0;C<M;C++)
       B[R][C]=A[C][R];
}

Structure

A structure is a collection of variable which can be same or different types. You can refer to a structure as a single variable, and to its parts as members of that variable by using the dot (.) operator. The power of structures lies in the fact that once defined, the structure name becomes a user-defined data type and may be used the same way as other built-in data types, such as int, double, char.

struct STUDENT
{
        int rollno, age;
        char name[80];
        float marks;
} ;
int main()
{
       // declare two variables of the new type
       STUDENT s1, s3;
       //accessing of data members
       cin>>s1.rollno>>s1.age>>s1.name>>s1.marks;
       cout<<s1.rollno<<s1.age<<s1.name<<s1.marks;
      //initialization of structure variable
       STUDENT s2 = {100,17,”Aniket”,92};
       cout<<s2.rollno<<s2.age<<s2.name<<s2.marks;
       //structure variable in assignment statement
       s3=s2;
       cout<<s3.rollno<<s3.age<<s3.name<<s3.marks;
       return 0;
}

Defining a structure

When dealing with the students in a school, many variables of different types are needed. It may be necessary to keep track of name, age, Rollno, and marks point for example. struct STUDENT
{
        int rollno, age;
        char name[80];
        float marks;
};
STUDENT  is called the structure tag, and is your brand new data type, like int, double or char.

rollno, name, age, and marks are structure members.

Declaring Variables of Type struct

The most efficient method of dealing with structure variables is to define the structure globally. This tells "the whole world", namely main and any functions in the program, that a new data type exists. To declare a structure globally, place itBEFORE void main(). The structure variables can then be defined locally in main, for example…

struct STUDENT
{
        int rollno, age;
        char name[80];
        float marks;
};
int main()
{
       // declare two variables of the new type
       STUDENT s1, s3;
       ………
       ………
       return 0;
}

Alternate method of declaring variables of type struct:

struct STUDENT
{
        int rollno, age;
        char name[80];
        float marks;
} s1, s3;

Accessing of data members

The accessing of data members is done by using the following format:
structure variable.member name
for example cin>>s1.rollno>>s1.age>>s1.name>>s1.marks;

Initialization of structure variable

Initialization is done at the time of declaration of a variable. For example
STUDENT s2 = {100,17,”Aniket”,92};

Structure variable in assignment statement
s3=s2;
The statement assigns the value of each member of s2 to the corresponding member of s3. Note that one structure variable can be assigned to another only when they are of the same structure type, otherwise complier will give an error.

Nested structure (Structure within structure)

It is possible to use a structure to define another structure. This is called nesting of structure. Consider the following program
struct DAY
{
     int month, date, year;
};
struct STUDENT
{
        int rollno, age;
        char name[80];
        day date_of_birth;
        float marks;
};

typedef

It is used to define new data type for an existing data type. It provides and alternative name for standard data type. It is used for self documenting the code by allowing descriptive name for the standard data type.

The general format is:
typedef existing datatype new datatype
for example:
typedef float real;
Now, in a program one can use datatype real instead of float.
Therefore, the following statement is valid:
real amount;

Enumerated data type

The enum specifier defines the set of names which are stored internally as integer constant. The first name was given the integer value 0, the second value 1 and so on.

for example:

enum months{jan, feb, mar, apr, may} ;

It has the following features:

· It is user defined.

· It works if you know in advance a finite list of values that a data type can take.

· The list cannot be input by the user or output on the screen.

#define preprocessor directive

The #define preprocessor allows to define symbolic names and constants e.g.#define pi 3.14159
This statement will translate every occurrence of PI in the program to 3.14159

Macros

Macros are built on the #define preprocessor. Normally a macro would look like:#define square(x) x*x
Its arguments substituted for replacement text, when the macro is expanded.

OOP Concepts

Paradigm-: It means organizing principle of a program. It is an approach to programming.

Procedural Paradigm
In procedural programming paradigm, the emphasis is on doing things i.e., the procedure or the algorithm. The data takes the back seat in procedural programming paradigm. Also, this paradigm does not model real world well.

Object Oriented programming
The object oriented programming paradigm models the real world well and overcomes the shortcomings of procedural paradigm. It views a problem in terms of objects and thus emphasizes on both procedures as well as data.

The following are the basic concepts used in object-oriented programming.

Object-: An object is an identifiable entity with some characteristics and behavior.

Class-: A class represents a group of objects that share common properties, behavior and relationships.

Data Abstraction-: Abstraction refers to act of representing essential features without including the background details or explanations.

Encapsulation-: The wrapping up of data and associated functions into a single unit is known as Encapsulation. Encapsulation implements data abstraction.

Modularity-: Modularity is the property of a system that has been decomposed into a set of cohesive and loosely coupled modules.

Inheritance-: It is the capability of one class of things to inherit capabilities or properties from another class.

Base and sub classes-: The class whose properties are inherited is called base class (or superclass) and the class that inherits the properties is known as derived class(or subclass).

Derived Class :- The class, which inherits from other classes is called derived class or Subclass.

Polymorphism-: It is the ability for a message or data to be processed in more than one form. Polymorphism is a property by which the same message can be sent to objects of several different classes. Polymorphism is implemented in C++ through virtual functions and overloading- function overloading and operator overloading.

Advantages of Object oriented programming.
Software complexity can be easily managed
Object-oriented systems can be easily upgraded
It is quite easy to partition the work in a project based on object

class enforce data-hiding, abstraction & encapsulation
A class groups its members into three sections : private, protected, and public. The private and protected members remain hidden from outside world. Thus through private and protected members, a class enforces data-hiding.

The outside world is given only the essential and necessary information through public members, rest of the things remain hidden, which is nothing but abstraction. Abstraction means representation of essential features without including the background details and explanation.

Class & Oobjects

The mechanism that allows you to combine data and the function in a single unit is called a class. Once a class is defined, you can declare variables of that type. A class variable is called object or instance. In other words, a class would be the data type, and an object would be the variable. Classes are generally declared using the keyword class, with the following format:

class class_name
{
   private:
      members1;
   protected:
      members2;
   public:
      members3;
};

Where class_name is a valid identifier for the class. The body of the declaration can contain members, that can be either data or function declarations, The members of a class are classified into three categories: private, public, and protected. Private, protected, and public are reserved words and are called member access specifiers. These specifiers modify the access rights that the members following them acquire.

private members of a class are accessible only from within other members of the same class. You cannot access it outside of the class.
protected members are accessible from members of their same class and also from members of their derived classes.
Finally, public members are accessible from anywhere where the object is visible.

By default, all members of a class declared with the class keyword have private access for all its members. Therefore, any member that is declared before one other class specifier automatically has private access.

Here is a complete example :

class student
{
private :
   int rollno;
    float marks;
public:
   void getdata()
    {
       cout<<"Enter Roll Number : ";
       cin>>rollno;
       cout<<"Enter Marks : ";
       cin>>marks;
    }
    void displaydata()
    {
       cout<<"Roll number : "<<rollno<<"\nMarks : "<<marks;
    }
};

Object Declaration

Once a class is defined, you can declare objects of that type. The syntax for declaring a object is the same as that for declaring any other variable. The following statements declare two objects of type student:

student st1, st2;

Accessing Class Members

Once an object of a class is declared, it can access the public members of the class.

st1.getdata();

Defining Member function of class

You can define Functions inside the class as shown in above example. Member functions defined inside a class this way are created as inline functions by default. It is also possible to declare a function within a class but define it elsewhere. Functions defined outside the class are not normally inline.
When we define a function outside the class we cannot reference them (directly) outside
of the class. In order to reference these, we use the scope resolution operator, ::
(double colon). In this example, we are defining function getdata outside the class:void student :: getdata()
{
     cout<<"Enter Roll Number : ";
     cin>>rollno;
     cout<<"Enter Marks : ";
     cin>>marks;
}

The following program demostrates the general feature of classes. Member function initdata() is defined inside the class. Member funcitons getdata() and showdata() defined outside the class.

class student //specify a class
{
private :
   int rollno; //class data members
    float marks;
public:
   void initdata(int r, int m)
   {
      rollno=r;
      marks=m;
   }
    void getdata(); //member function to get data from user
    void showdata();// member function to show data
};

void student :: getdata()
{
    cout<<"Enter Roll Number : ";
    cin>>rollno;
    cout<<"Enter Marks : ";
    cin>>marks;
}

void student :: showdata()
{
    cout<<"Roll number : "<<rollno<<"\nMarks : "<<marks;
}

int main()
{
    student st1, st2; //define two objects of class student
    st1.initdata(5,78); //call member function to initialize
    st1.showdata();
    st2.getdata(); //call member function to input data
    st2.showdata(); //call member function to display data
    return 0;
}

Constructor and Destructor

Constructor

It is a member function having same name as it’s class and which is used to initialize the objects of that class type with a legel initial value. Constructor is automatically called when object is created.

Types of Constructor

Default Constructor-: A constructor that accepts no parameters is known as default constructor. If no constructor is defined then the compiler supplies a default constructor.

student :: student()
{
rollno=0;
marks=0.0;
}

Parameterized Constructor -: A constructor that receives arguments/parameters, is called parameterized constructor.

student :: student(int r)
{
rollno=r;
}

Copy Constructor-: A constructor that initializes an object using values of another object passed to it as parameter, is called copy constructor. It creates the copy of the passed object.

student :: student(student &t)
{
rollno = t.rollno;
}

There can be multiple constructors of the same class, provided they have different signatures.

Destructor

A destructor is a member function having sane name as that of its class preceded by ~(tilde) sign and which is used to destroy the objects that have been created by a constructor. It gets invoked when an object’s scope is over.

~student() { }

Example : In the following program constructors, destructor and other member functions are defined inside class definitions. Since we are using multiple constructor in class so this example also illustrates the concept of constructor overloading

#include<iostream.h>

class student //specify a class
{
private :
   int rollno; //class data members
    float marks;
public:
   student() //default constructor
   {
      rollno=0;
      marks=0.0;
   }
   student(int r, int m) //parameterized constructor
   {
      rollno=r;
      marks=m;
   }
   student(student &t) //copy constructor
   {
      rollno=t.rollno;
      marks=t.marks;
   }
    void getdata() //member function to get data from user
   {
       cout<<"Enter Roll Number : ";
       cin>>rollno;
       cout<<"Enter Marks : ";
       cin>>marks;
   }
    void showdata() // member function to show data
    {
       cout<<"\nRoll number: "<<rollno<<"\nMarks: "<<marks;
    }
    ~student() //destructor
    {}
};

int main()
{
    student st1; //defalut constructor invoked
    student st2(5,78); //parmeterized constructor invoked
    student st3(st2); //copy constructor invoked
    st1.showdata(); //display data members of object st1
    st2.showdata(); //display data members of object st2
    st3.showdata(); //display data members of object st3
    return 0;
}

Inheritance

Inheritance:It is the capability of one class to inherit properties from another class.

Base Class: It is the class whose properties are inherited by another class. It is also called Super Class.

Derived Class:It is the class that inherit properties from base class(es).It is also called Sub Class.

Forms Of Inheritance

Single Inheritance: It is the inheritance hierarchy wherein one derived class inherits from one base class.

Multiple Inheritance:It is the inheritance hierarchy wherein one derived class inherits from multiple base class(es)

Hierarchical Inheritance: It is the inheritance hierarchy wherein multiple subclasses inherits from one base class.

Multilevel Inheritance: It is the inheritance hierarchy wherein subclass acts as a base class for other classes.

Hybrid Inheritance:The inheritance hierarchy that reflects any legal combination of other four types of inheritance.

Visibility Mode:It is the keyword that controls the visibility and availability of inherited base class members in the derived class.It can be either private or protected or public.

Private Inheritance:It is the inheritance facilitated by private visibility mode.In private inheritance ,the protected and public members of base class become private members of the derived class.

Public Inheritance:It is the inheritance facilitated by public visibility mode.In public inheritance ,the protected members of base class become protected members of the derived class and public members of the base class become public members of derived class.;

Protected Inheritance:It is the inheritance facilitated by protected visibility mode.In protected inheritance ,the protected and public members of base class become protected members of the derived class.

Base Class Visibility	Derived class visibility
Base Class Visibility	Public derivation	Private derivation	Protected derivation
Private	Not inherited	Not inherited	Not inherited
Protected	Protected	Private	Protected
Public	Public	Private	Protected

Containership:When a class contains objects of other class types as its members, it is called containership.It is also called containment,composition, aggregation.

Execution of base class constructor

Method of inheritace	Order of execution
class B : public A { };	A(); base constructor B(); derived constructor
class A : public B, public C	B();base (first) C();base (second) A();derived constructor

When both derived and base class contains constructors, the base constructor is executed first and then the constructor in the derived class is executed. In case of multiple inheritances, the base classes are constructed in the order in which they appear in the declaration of the derived class.

Overriding of method(function) in inheritance

We may face a problem in multiple inheritance, when a function with the same name appears in more than one base class. Compiler shows ambiguous error when derived class inherited by these classes uses this function.

We can solve this problem, by defining a named instance within the derived class, using the class resolution operator with the function as below :

class P : public M, public N        //multiple inheritance
{
public :
   void display() //overrides display() of M and N
   {
      M::display()
   }
};

we can now used the derived class as follows :
void main()
{
P obj;
obj.display();
}

Virtual Base Class

Multipath inheritance may lead to duplication of inherited members from a grandparent base class. This may be avoided by making the common base class a virtual base class. When a class is made a virtual base class, C++ takes necessary care to see that only one copy of that class is inherited.

class A
{
....
....
};

class B1 : virtual public A

{
....
....
};
class B2 : virtual public A
{
....
....
};
class C : public B1, public B2
{
.... // only one copy of A
.... // will be inherited
};

Data File Handling In C++

File. The information / data stored under a specific name on a storage device, is called a file.

Stream. It refers to a sequence of bytes.

Text file. It is a file that stores information in ASCII characters. In text files, each line of text is terminated with a special character known as EOL (End of Line) character or delimiter character. When this EOL character is read or written, certain internal translations take place.

Binary file. It is a file that contains information in the same format as it is held in memory. In binary files, no delimiters are used for a line and no translations occur here.

Classes for file stream operation

ofstream: Stream class to write on files
ifstream: Stream class to read from files
fstream: Stream class to both read and write from/to files.

Opening a file

OPENING FILE USING CONSTRUCTOR
ofstream fout(“results”); //output only
ifstream fin(“data”); //input only

OPENING FILE USING open()
Stream-object.open(“filename”, mode)

      ofstream ofile;
      ofile.open(“data1”);

      ifstream ifile;
      ifile.open(“data2”);

File mode parameter	Meaning
ios::app	Append to end of file
ios::ate	go to end of file on opening
ios::binary	file open in binary mode
ios::in	open file for reading only
ios::out	open file for writing only
ios::nocreate	open fails if the file does not exist
ios::noreplace	open fails if the file already exist
ios::trunc	delete the contents of the file if it exist

All these flags can be combined using the bitwise operator OR (|). For example, if we want to open the file example.bin in binary mode to add data we could do it by the following call to member function open():

fstream file;
file.open ("example.bin", ios::out | ios::app | ios::binary);

Closing File

fout.close();
fin.close();

INPUT AND OUTPUT OPERATION

put() and get() function
the function put() writes a single character to the associated stream. Similarly, the function get() reads a single character form the associated stream.
example :
file.get(ch);
file.put(ch);

write() and read() function
write() and read() functions write and read blocks of binary data.
example:
file.read((char *)&obj, sizeof(obj));
file.write((char *)&obj, sizeof(obj));

ERROR HANDLING FUNCTION

FUNCTION	RETURN VALUE AND MEANING
eof()	returns true (non zero) if end of file is encountered while reading; otherwise return false(zero)
fail()	return true when an input or output operation has failed
bad()	returns true if an invalid operation is attempted or any unrecoverable error has occurred.
good()	returns true if no error has occurred.

File Pointers And Their Manipulation

All i/o streams objects have, at least, one internal stream pointer:
ifstream, like istream, has a pointer known as the get pointer that points to the element to be read in the next input operation.

ofstream, like ostream, has a pointer known as the put pointer that points to the location where the next element has to be written.

Finally, fstream, inherits both, the get and the put pointers, from iostream (which is itself derived from both istream and ostream).

These internal stream pointers that point to the reading or writing locations within a stream can be manipulated using the following member functions:

seekg()	moves get pointer(input) to a specified location
seekp()	moves put pointer (output) to a specified location
tellg()	gives the current position of the get pointer
tellp()	gives the current position of the put pointer

The other prototype for these functions is:

seekg(offset, refposition );
seekp(offset, refposition );

The parameter offset represents the number of bytes the file pointer is to be moved from the location specified by the parameter refposition. The refposition takes one of the following three constants defined in the ios class.

ios::beg          start of the file
ios::cur          current position of the pointer
ios::end          end of the file

example:
file.seekg(-10, ios::cur);

Basic Operation On Text File In C++

Program to write in a text file

#include<fstream.h>
int main()
{
     ofstream fout;
     fout.open("out.txt");
     char str[300]="Time is a great teacher but unfortunately it kills all its pupils. Berlioz";
     fout<<str;
     fout.close();
     return 0;
}

Program to read from text file and display it

#include<fstream.h>
#include<conio.h>
int main()
{
     ifstream fin;
     fin.open("out.txt");
     char ch;
     while(!fin.eof())
     {
          fin.get(ch);
          cout<<ch;
     }
     fin.close();
     getch();
     return 0;
}

Program to count number of characters.

#include<fstream.h>
#include<conio.h>
int main()
{
     ifstream fin;
     fin.open("out.txt");
     clrscr();
     char ch; int count=0;
     while(!fin.eof())
     {
          fin.get(ch);
          count++;
     }
     cout<<"Number of characters in file is "<<count;
     fin.close();
     getch();
     return 0;
}

Program to count number of words

#include<fstream.h>
#include<conio.h>
int main()
{
     ifstream fin;
     fin.open("out.txt");
     char word[30]; int count=0;
     while(!fin.eof())
     {
          fin>>word;
          count++;
     }
     cout<<"Number of words in file is "<<count;
     fin.close();
     getch();
     return 0;
}

Program to count number of lines

#include<fstream.h>
#include<conio.h>
int main()
{
     ifstream fin;
     fin.open("out.txt");
     char str[80]; int count=0;
     while(!fin.eof())
     {
          fin.getline(str,80);
          count++;
     }
     cout<<"Number of lines in file is "<<count;
     fin.close();
     getch();
     return 0;
}

Program to copy contents of file to another file.

#include<fstream.h>
int main()
{
     ifstream fin;
     fin.open("out.txt");
     ofstream fout;
     fout.open("sample.txt");
     char ch;
     while(!fin.eof())
     {
          fin.get(ch);
          fout<<ch;
     }
     fin.close();
     return 0;
}

Basic Operation On Binary File In C++

class student
{
          int admno;
          char name[20];
public:
          void getdata()
          {
                     cout<<"\nEnter The admission no. ";
                     cin>>admno;
                     cout<<"\n\nEnter The Name of The Student ";
                     gets(name);
          }
          void showdata()
          {
                     cout<<"\nAdmission no. : "<<admno;
                     cout<<"\nStudent Name : ";
                     puts(name);
          }
          int retadmno()
          {
                     return admno;
          }
};

function to write in a binary file

void write_data()
{
          student obj;
          ofstream fp2;
          fp2.open("student.dat",ios::binary|ios::app);
          obj.getdata();
          fp2.write((char*)&obj,sizeof(obj));
          fp2.close();
}

function to display records of file

void display()
{
          student obj;
          ifstream fp1;
          fp1.open("student.dat",ios::binary);
          while(fp1.read((char*)&obj,sizeof(obj)))
          {
                     obj.showdata();
          }
}
          fp.close();
}

Function to search and display from binary file

void search (int n)
{
          student obj;
          ifstream fp1;
          fp1.open("student.dat",ios::binary);
          while(fp1.read((char*)&obj,sizeof(obj)))
          {
                     if(obj.retadmno()==n)
                              obj.showdata();
          }
          fp1.close();
}

Function to delete a record

void deleterecord(int n)
{
          student obj;
          ifstream fp1;
          fp1.open("student.dat",ios::binary);
          ofstream fp2;
          fp2.open("Temp.dat",ios::out|ios::binary);
          while(fp1.read((char*)&obj,sizeof(obj)))
          {
                      if(obj.retadmno!=n)
                                  fp2.write((char*)&obj,sizeof(obj));
          }
          fp1.close();
          fp2.close();
          remove("student.dat");
          rename("Temp.dat","student.dat");
}

Function to modify a record

void modifyrecord(int n)
{
          fstream fp;
          student obj;
          int found=0;
          fp.open("student.dat",ios::in|ios::out);
          while(fp.read((char*)&obj,sizeof(obj)) && found==0)
          {
                     if(obj.retadmno()==n)
                     {
                              obj.showdata();
                              cout<<"\nEnter The New Details of student";
                              obj.getdata();
                              int pos=-1*sizeof(obj);
                              fp.seekp(pos,ios::cur);
                              fp.write((char*)&obj,sizeof(obj));
                              found=1;
                    }
          }
          fp.close();
}

Pointer

C++ Memory Map

Once a program is compiled, C++ creates four logically distinct regions of memory:
Code Area : Area to hold the compiled program code
Data Area : Area to hold global variables
Stack Area : Area to hold the return address of function calls, argument passed to the functions, local variables for functions and the current state of the CPU.
Heap : Area from which the memory is dynamically allocated to the program.

Accessing address of a variable

Computer’s memory is organized as a linear collection of bytes. Every byte in the computer’s memory has an address. Each variable in program is stored at a unique address. We can use address operator & to get address of a variable:
int num = 23;
cout << &num; // prints address in hexadecimal

POINTER

A pointer is a variable that holds a memory address, usually the location of another variable in memory.

Defining a Pointer Variable
int *iptr;
iptr can hold the address of an int

Pointer Variables Assignment:
int num = 25;
int *iptr;
iptr = &num;

Memory layout

To access num using iptr and indirection operator *
cout << iptr; // prints 0x4a00
cout << *itptr; // prints 25

Similary, following declaration shows:
char *cptr;
float *fptr;
cptr is a pointer to character and fptr is a pointer to float value.

Pointer Arithmetic

Some arithmetic operators can be used with pointers:
   - Increment and decrement operators ++, --
    - Integers can be added to or subtracted from
      pointers using the operators +, -, +=, and -=

Each time a pointer is incremented by 1, it points to the memory location of the next element of its base type.
If “p” is a character pointer then “p++” will increment “p” by 1 byte.
If “p” were an integer pointer its value on “p++” would be incremented by 2 bytes.

Pointers and Arrays

Array name is base address of array
            int vals[] = {4, 7, 11};
            cout << vals;       // displays 0x4a00
            cout << vals[0]; // displays 4

Lets takes an example:

int arr[]={4,7,11};
int *ptr = arr;
What is ptr + 1?
It means (address in ptr) + (1 * size of an int)
cout << *(ptr+1); // displays 7
cout << *(ptr+2); // displays 11

Array Access
Array notation arr[i] is equivalent to the pointer notation *(arr + i)

Assume the variable definitions
   int arr[]={4,7,11};
   int *ptr = arr;
Examples of use of ++ and --
   ptr++; // points at 7
   ptr--; // now points at 4

Character Pointers and Strings

Initialize to a character string.
char* a = “Hello”;
a is pointer to the memory location where ‘H’ is stored. Here “a” can be viewed as a character array of size 6, the only difference being that a can be reassigned another memory location.
char* a = “Hello”;
a         gives address of ‘H’
*a        gives ‘H’
a[0]      gives ‘H’
a++      gives address of ‘e’
*a++    gives ‘e’

Pointers as Function Parameters

A pointer can be a parameter. It works like a reference parameter to allow change to argument from within function

Pointers as Function Parameters
       void swap(int *x, int *y)
       {
          int temp;
                              temp = *x;
                              *x = *y;
                              *y = temp;
       }
      swap(&num1, &num2);

Pointers to Constants and Constant Pointers

Pointer to a constant: cannot change the value that is pointed at
Constant pointer: address in pointer cannot change once pointer is initialized

Pointers to Structures

We can create pointers to structure variables

            struct Student {int rollno; float fees;};
            Student stu1;
            Student *stuPtr = &stu1;
            (*stuPtr).rollno= 104;
-or-
Use the form ptr->member:
            stuPtr->rollno = 104;

Static allocation of memory

In the static memory allocation, the amount of memory to be allocated is predicted and preknown. This memory is allocated during the compilation itself. All the declared variables declared normally, are allocated memory statically.

Dynamic allocation of memory

In the dynamic memory allocation, the amount of memory to be allocated is not known. This memory is allocated during run-time as and when required. The memory is dynamically allocated using new operator.

Free store

Free store is a pool of unallocated heap memory given to a program that is used by the program for dynamic allocation during execution.

Dynamic Memory Allocation

We can allocate storage for a variable while program is running by using new operator

To allocate memory of type integer
int *iptr=new int;

To allocate array
double *dptr = new double[25];

To allocate dynamic structure variables or objects
Student sptr = new Student; //Student is tag name of structure

Releasing Dynamic Memory

Use delete to free dynamic memory
delete iptr;
To free dynamic array memory
delete [] dptr;
To free dynamic structure
delete Student;

Memory Leak

If the objects, that are allocated memory dynamically, are not deleted using delete, the memory block remains occupied even at the end of the program. Such memory blocks are known as orphaned memory blocks. These orphaned memory blocks when increase in number, bring adverse effect on the system. This situation is called memory leak

Self Referential Structure

The self referential structures are structures that include an element that is a pointer to another structure of the same type.

struct node
{
int data;
node* next;
}

Static Stack

#include<iostream.h>
#include<conio.h>
#define size 4

class stack
{
     int data[size];
     int top;
public:
     stack()
     {
          top=-1;
     }
     void push();
     void pop();
     void display();
};

void stack::push()
{
     if(top==size-1)
     {
          cout<<"\nStack is full";
          return;
     }
     else
     {
          top++;
          cout<<"Enter Data : ";
          cin>>data[top];
     }
}

void stack::pop()
{
     if(top==-1)
          cout<<"\n Stack is empty";
     else
     {
          cout<<data[top]<<"deleted "<<endl;
          top--;
     }
}

void stack::display()
{
     int t=top;
     while(t>=0)
     {
          cout<<data[t]<<endl;
          t--;
     }
}

void main()
{
     stack st;
     int ch;
     do
     {
          cout<<"\n1. Push\n2. Pop\n3. Display \n4.Quit\nEnter Choice(1-4) ";
          cin>>ch;
          switch(ch)
          {
               case 1: st.push();break;
               case 2: st.pop();break;
               case 3: st.display();
          }
     }while(ch!=4);
}

Static Circular Queue

#include<iostream.h>
#include<conio.h>
#define size 4

class cqueue
{
      int data[size];
      int front,rear;
public:
      cqueue()
      {
            front=-1;rear=-1;
      }
      void insert();
      void remove();
};

void cqueue::insert()
{
      if(rear==size-1&&front==0 || front==rear+1)
      {
            cout<<"\nCircular queue is full";
            return;
      }
      else if(rear==-1)
      {
            rear++;
            front++;
      }
      else if(rear==size-1)
            rear=0;
      else
            rear++;

cout<<"Enter Data : ";
cin>>data[rear];
}

void cqueue::remove()
{
      if(front==-1)
      {
            cout<<"\n Circular Queue is empty";return;
      }

cout<<data[front]<<" deleted"<<endl;

      if(front==rear)
      {
            front=-1;rear=-1;
      }
      else if(front==size-1)
            front=0;
      else
            front++;
}

void main()
{
      cqueue cq;
      int ch;
      do
      {
            cout<<"\n1. Insert\n2. Remove\n3. Quit\nEnter Choice(1-3) ";
            cin>>ch;
            switch(ch)
            {
                  case 1: cq.insert();break;
                  case 2: cq.remove();break;
            }
      }while(ch!=3);
}

Dynamic Stack

Stack is a linear data structure in which insertion and deletion of elements takes place only one end known as TOP.

#include<iostream.h>
#include<conio.h>

struct node
{
int data;
node *next;
};

class stack
{
      node *top;
public :
      stack()
      { top=NULL;}
      void push();
      void pop();
      void display();
      ~stack();
};

void stack::push()
{
      node *temp;
      temp=new node;
      cout<<"Enter data :";
      cin>>temp->data;
      temp->next=top;
      top=temp;
}

void stack::pop()
{
      if(top!=NULL)
      {
            node *temp=top;
            top=top->next;
            cout<<temp->data<<"deleted";
            delete temp;
      }
      else
            cout<<"Stack empty";
}

void stack::display()
{
      node *temp=top;
      while(temp!=NULL)
      {
      cout<<temp->data<<" ";
      temp=temp->next;
      }
}

stack::~stack()
{
      while(top!=NULL)
      {
            node *temp=top;
            top=top->next;
            delete temp;
      }
}

void main()
{
      stack st;
      char ch;
      do
      {
            cout<<"stack options\nP for push \nO for Pop \nD for Display \nQ for quit";
            cin>>ch;
            switch(ch)
            {
                  case 'P': st.push();break;
                  case 'O': st.pop();break;
                  case 'D': st.display();break;
            }
      }while(ch!='Q');
}

Dynamic Queue

Queue is a linear data structure in which insertion and deletion of elements takes place from two opposite ends rear and front respectively.

#include<iostream.h>
#include<conio.h>

struct node
{
int data;
node *next;
};

class queue
{
      node *rear,*front;
public:
      queue()
      { rear=NULL;front=NULL;}
      void qinsert();
      void qdelete();
      void qdisplay();
      ~queue();
};

void queue::qinsert()
{
      node *temp;
      temp=new node;
      cout<<"Data :";
      cin>>temp->data;
      temp->next=NULL;
      if(rear==NULL)
      {
            rear=temp;
            front=temp;
      }
      else
      {
            rear->next=temp;
            rear=temp;
      }
}

void queue::qdelete()
{
      if(front!=NULL)
      {
            node *temp=front;
            cout<<front->data<<"deleted \n";
            front=front->next;
            delete temp;
            if(front==NULL)
                  rear=NULL;
      }
      else
            cout<<"Queue Empty..";
}

void queue::qdisplay()
{
      node *temp=front;
      while(temp!=NULL)
      {
            cout<<temp->data<<endl;
            temp=temp->next;
      }
}

queue::~queue()
{
      while(front!=NULL)
      {
            node *temp=front;
            front=front->next;
            delete temp;
      }
}

void main()
{
      queue obj; char ch;
      do
      {
            cout<< "i. insert\nd. Delete\ns. Display\n q. quit ";
            cin>>ch;
            switch(ch)
            {
                  case 'i' : obj.qinsert();break;
                  case 'd' : obj.qdelete();break;
                  case 's' : obj.qdisplay();
            }
      }while(ch!='q');
}