Programming paradigm: Programming Programming paradigm means that the fundamental of computer programming. Programming Programming style or methods are changed from language to language. There are three programming paradigm – paradigm –
1. Imperative / Procedural: Imperative programming languages are the most traditional once. Their code consists of sequential statements to achieve the desired goal. For Ex: Basic and Pascal 2. Functional / Modular: Functional programming programming languages are as name suggest, the problems are divided into functions / modules. For Ex: C 3. Object Oriented: Object oriented programming languages; they mainly focus around objects that have their own properties and procedural / method. It is also possible to create classes that include the functionality of other already existing classes. Need of OOPs: Characteristics Characteristics of OOPs: i. Emphasis on data rather than procedure. ii. Programs are divided into what are known as objects. iii. Function and data are tied together in a data structure. iv. Data is hidden and cannot be accessed by external functions. v. Objects may communicate with classes through functions. vi. New data and functions functions can be easily easily added whenever necessary. vii. Follows bottom up approach in program design.
a. b. c. d. e.
Some other characteristics included in C++: Ability to declare variable anywhere. New data types like long long int, int, Boolean and complex data type type to denote complex numbers. New header file such as stdbool.h, stdbool.h, inttypes.h. inttypes.h. C++ supports exceptional handling for handling errors. C++ introduced new keywords like new, delete, inline, public, private, this etc.
Comparative study of C and C++: Designed by String type
Major Implementations Program I/O Speed
Program Include Language type Influenced Appeared in OOP Paradigm Execution flow
C Designed by Dennis Ritchie
Cannot use string type by declare it using as an array of characters GCC, Borland C, MS VC scanf for input or printf for output C applications are faster to compile and execute than C++ applications Uses #include
Procedural oriented language awk, C#, objective-C, Pearl, PHP, Java, C++, JavaScript 1972 Not built in Procedural system implementation language Top to Bottom
C++ Designed by B. Jarne Stroustrp Can use string type, using ‘string’ data type
MSVC++ cin for input or cout for output C++ applications are generally slower at runtime and are much slower to compile than C Uses #include Object Oriented language Java, PHP, Pearl, JavaScript, Ada 95, D 1985 Yes, polymorphism and inheritance Multi paradigm language Bottom to Top
Principles of Object oriented programming: Objects: i. Objects are basic runtime entities in an object oriented system. ii. In Structured programming problem is divided into function unlike this, in OOPs the problem is divided into objects. Diagram Class:
Language supports different data type like int, float, char, long, structure etc. Similar to that C++ supports class data type. A class data type contains variable and functions. They can be accessed through class variables (Objects). (Objects). For Ex: Fruit is a class. Then mango, orange will be objects of class. Inheritance:
It is a process by which object of one class acquire the properties of object of another class. 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 once. The new class will have the combined feature of both the classes.
Abstraction:
It is referred to the act of representing essential feature without including background detail detail or explanation. Class use the concept of abstraction abstraction and are are defined as abstract attributes such as size, weight and cost.
Encapsulation:
The wrapping of data and functions into a single unit (class) is known as encapsulation. The data is not accessible to outside world and those functions which are wrapped into the class can access it. It is also known as data hiding. Polymorphism:
It means use one thing in more than one form. Operator overloading overloading & function overloading are examples of polymorphism. polymorphism. Function Overloading: The function name has more than one definition in a class according to arguments passed to a function. function. Operator Overloading: Uses predefined operators as function name and allow giving it new definition.
Structure of C++ Program: Include file Class declaration Member function definition Main function
1. Include File: In this section, we add header files and resource files. These files provide definition for function and object used in a program. 2. Class Declaration: In this area class is defined. Ex: class demo { Member variables and functions }; 3. Member Function Definition: In this section class member, function and other functions are defined. Ex: demo :: fun() { Definition } 4. Main Function: This is special type of function that is called at the beginning of program execution. Each program must have one main function. int main() { return 0; }
Reference Variable: A reference variable provides an alias (alternative name) for a previously defined variable. Syntax: Data type & reference_name = variable_name; Ex: int a=10; int &b=a; Comparative study of pointer & reference variable: i. A pointer can be reassigned any number of time, while a reference variable cannot be reassigned after initialization. ii. A pointer can point to NULL but reference variable always point to a value. iii. We cannot take the address of reference variable like we can do with pointer variable.
Note: Some other properties of C++ Declaration of variable: The C++ allows the declaration of variable anywhere in the program. Dynamic initialization of variable: Variable can be initialized at runtime using expression at the place of declaration. Ex: int sum; int a=sum;
Memory Management Operators in C++: To allocate memory, C++ supports two unary operators new and delete. These operators allocate and deallocate the memory in better and easy way.
Advantages of new operator over malloc function: i. It automatically computes the size of data object. We need not use the operator sizeof(); ii. It automatically returns the current pointer type so there is no need to type cast. iii. Like any other operator new and delete can be overloaded. iv. It is possible to initialize the object while allocating the memory. Syntax for “ new ”: Data type pointer_variable = new data type; Ex: int *p = new int; OR int *p; *p = new int;
Note: We can also initialize the memory using new operator. Pointer_variable = new data type (value); Ex: int *p = new int (0); Note: We can also allocate memory space to array. Pointer_variable = new data type [size]; Ex: int *p = new int[5];
Inline Function: Inline function’s definition is placed where it is called in the program. It provides faster execution by ignoring the function calling process. Member function of class is defined inline by default. We can define any function as inline using the keyword inline while defining it.
If following statements written in function body, the inline function may not work – If inline function is recursive. Loop, switch and goto statement Static variable Returning from exit(0) statement
Constructor: A constructor is a special member function whose task is to initialize the object of its class. Constructor name is the same as the class name. The constructor is called whenever an object of its associated class is created. For Ex: class integer () { private: int n, m; public: integer () { n=0; m=0; } };
i. ii. iii. iv.
Characteristics of Constructor: They should be declared in public section. They are called automatically when class objects are declared. They do not have return type so they cannot return any value. They cannot be inherited, derived class can call base call constructor.
Types of constructor: 1. Default constructor 2. Parameterized constructor 3. Copy constructor 1. Default constructor: When a constructor is called without any argument and it is called automatically when object is created, this is called default constructor. 2. Parameterized constructor: When a constructor is called with parameters while creating an object; such type of constructor is called parameterized constructor. class integer () { private: int n, m; public: integer () //Default {
n=0; m=0; } integer (int x, int y); };
integer::integer(int x, int y) //Parameterized { n=x; m=y; } 3. Copy constructor: A constructor takes a reference of an object of the same class, itself as an argument. A reference variable is used as argument in constructor such a constructor is called copy constructor.
class emp { private: int id; public: emp(int a) { id=a; } emp(emp &obj) { id=obj.id; } Void display() { cout<<”id”<
emp y(x); cout<<”x”; x.display(); cout<<”y”; y.display(); }
Destructor: A member function that names same as class name preceded by a tilde (~) sign. Such types of function are called destructor.
class ex { static int count; public: ex() { count++; cout<<”No. of object created”<
Operator Overloading in C++: It is a special feature of C++. C++ allows operators to be use as function name and allow user to redefine them with new functionality. Return_type classname::operator op() { statements } Unary operator overloading: When we have an operator that works on single operand such type of overloading is known as unary operator overloading. class minus { private: int a,b,c; public: void get() { cout<<”Enter value”; cin>>a>>b>>c; }
void get() { cout<<”Minus”; cout<
minus m; m.get(); m.display(); -m; // m.operator-(); m.display(); } Binary operator overloading: When we have an operator that works on two operands such type of overloading is known as binary operator overloading. class sum { private: Int x,y; pubic: sum() { x=10; y=10; } void display() { cout<<”value of x is ”<
}
getch();
Note: Operators that can’t be overloaded sizeof, ., .*, ::, ?:
Rules for Operator overloading: Existing operator can be overloaded new operator cannot be overloaded. The operator must have at least one operand i.e. a user defined type. We cannot change the basic meaning of an operator. Binary operator overloaded through a member function take one argument, those which are overloaded through a friend function take two argument. Unary operator overloaded by mean of a member function take no explicit argument and returns no explicit value. Those which are overloaded by the means of friend function take one reference argument.
Friend Class: A friend class in C++ can access the private and protected members of the class in which it is declared as friend. Friend status is not inherited; every friendship has to explicitly declare. Friend classes can help in improving encapsulation. A friend class has following characteristics: 1. It allows sharing private and protected member by a non -member function. 2. It provides function with data which is not normally used by the class.
#include class csqr; class crect; { int width,height; public: int area() { area(width*height); } void convert(csqr); };
class csqr { int side; public: void setvalue(int a) { Side=a; } friend class crect; }; void crect::convert(csqr obj) { width=obj.side; height=obj.side; } void main()
{ csqr sqr; crect rect; sqr.setvalue(10); rect.convert(sqr); cout<>(istream &,array &) ; }; ostream & operator<<(ostream &dout,array &obj) { for(int i=0;i<3;i++) dout<>(istream &din,array &obj) { for(int i=0;i<3;i++) din>>obj.a[i]; return din; } void main() { array show; clrscr(); cin>>show; cout<
Inheritance: It is process by which object of one class acquire the properties and functionalities of object of another class. The class that is predefined is called as base or super class, and the class which use the existing class is called as derived class or sub class. The various type of inheritance those are provided by C++ is as follows: i. Single Inheritance ii. Multi level Inheritance iii. Multiple Inheritance iv. Hierarchical Inheritance v. Hybrid Inheritance
i.
Single Inheritance: In this, there is only one super class & only one sub class, means they have one to one communication between them.
ii.
Multi level Inheritance: In this, a derived class can also inherited by another class, means when a derived class again will be inherited by another class then it create multiple levels of class.
iii.
Multiple inheritance: In this, a class inherits the features of two or more base classes.
iv.
Hierarchical Inheritance: In this, a base class has two or more sub classes or when a base class is used or inherited by many sub classes, it is called hierarchical inheritance.
v.
Hybrid Inheritance: In this type, it is a mixture of two or more inheritance. A code may contain two or three types of inheritance in a single call.
Derived Class OR Inheritance type Base Class
Public
Protected
Private
Public Protected Private
Public Protected Private
Protected Protected Private
class college { protected: char clg_name[10]; public: void clg_getvalue() { cout<<”value of college”; cin>>clg_name; } }; class dept:public college { private: char dept_name[10]; public: void dept_getvalue() { cout<<”value of dept”; cin>>dept_name; } void display() { cout<<”College name ”<
Not Inherit Not Inherit Not Inherit
}
Function Overriding: Redefining a base class function in the derived class to have our own implementation is referred as overriding. The signature of the function will be same.
For example:Class m { public: void display() { cout<<”Base class function”; } }; class n:public m { public: void display() { vout<<”Derived class function”; } }; void main() { n obj; obj.display(); obj.show(); obj.m::display(); getch(); }
Constructor in derived class: The base class contain constructor with one or more parameter, then it is mandatory for the derived class to have constructor and pass the parameter to the base class constructor. In the case of inheritance first base class constructor is called then derived class constructer is called. In the case of destructor first derived class destructor is called then base class destructor is called.
class Base { public: Base() { cout<<”Base class default constructor”; } Base(int a) { cout<<”Base class parameterized constructer”; } ~Base() { cout<<”Base class destructer”; } }; class Derived:public Base { public: Derived() { cout<<”Derived class default constructor”; } Derived(int b):Base(b) { cout<<”Derived class parameterized constructor”; } ~Derived() { cout<<”Derived class destructor”; }
}; void main() { clrscr(); { Derived obj(10); // parameterized } { Derived obj1; //Default } }
Binding
Static Binding : The mechanism of linking a function with an object during compile time, is called early binding or static binding. The non-virtual member functions are resolved at compile time; this mechanism is called static binding. Dynamic Binding : The mechanism of linking a function with an object at runtime is called late binding. The virtual member functions are resolved during runtime; this mechanism is known as dynamic binding.
Virtual Base Class: One base class can be inherit by multiple path and derived class may have multiple copies of base class members, so to inherit one copy of base class we make virtual inheritance of base class.
class A { }; class B: public virtual A { }; class C: virtual public A { }; class D: public B, public C { //one copy of A class is inherited };
Polymorphism:
Virtual Function: In the case of inheritance, it makes right function call on the time. When the same function name is defined in both base and derived class, the function in base class is declared as virtual using the keyword virtual in the function such a function is called virtual function. Ex:
class Base { public: void display() { cout<<”display base function”; } virtual void show() { cout<<”show base function”; } }; class Derived: public base { public: void display() { cout<<”display derived function”; } void show() {
cout<<”show derived function”; } }; void main() { Base *Ptr,b; Derived d; Ptr =&b; Ptr->show();//Base Ptr->display();//Base Ptr =&d; Ptr->show();//Derived Ptr->display();//Base } The rules for virtual function: I. The virtual function must be member function of some class. II. They are accessed by using object pointer. III. A virtual function can be a friend of another class. IV. We cannot have virtual constructor but we can have virtual destructor. V. If a virtual function is defined in the base class, it need not be necessary redefine in the derived class in such a case, base class function will be called.
Pure virtual function: A virtual function that does not have its own body and defined as empty function is known as pure virtual function.
virtual void function_name()=0; A pure virtual function is a function declared in a base class that has no definition. The compiler requires derived class to either define the function or re-declare it. A class containing pure virtual function cannot be used to declare any object of its own class. Abstract Class: It acts as expression of general concept from which more specific classes can be derived. We cannot create an object of an abstract class type but we can use pointer and reference to abstract class type. A class that contains at least one pure virtual function is called as abstract class. And classes derived from an abstract class must implement the pure virtual function.
For ex: class account { private: int balance; public: void getBalance(); virtual void printBalance()=0; }
Template: Templates are mechanism that is possible to use one function or class to handle many different data type by using template. Template is a feature of C++ programming language that allows function and class to operate generic function. Advantages: i. Template is linked at compile time. ii. Template reduces the size of code. iii. Templates are considered type-safe.
Disadvantages: i. The compiler generates additional code for each template type. Syntax: template
Template Function:
We can design a single function that operates on data of many types. Syntax: template return_type fun_name(argument type T) { //Body of function with type T }
Ex:
template void swap(T1 &x, T1 &y) { T1 temp; temp =x; x=y; y=temp; } void main() { int a=10,b=20; char x=’a’, y=’z’; float m=10.5, n=20.5; cout<<”After Swap : ”; cout<<”\n int a = ”<
Template Function Overloading: A template function may be overloaded either by template function or ordinary function. template void display(t1 x) { cout<<”Template function”<
} void main() { display(10); display(‘z’); display(10.50); }
Template Class:
template class test { T1 a; T2 b; public: test(T1 x , T2 y) { a=x; b=y; } void show() { cout< test1 (1.30,123); test test2 (10,’w’); test1.show(); test2.show(); getch(); } A class created from class template is called a template class. Syntax: class_name < type > object_name(argument list);
Exception Handling: Those errors comes in program at run time is known as exception. To manage these exceptions we create procedure, this is known as exception handling.
Advantages of exception handling: i. We can trace the error. ii. It makes error free program. Exception handling helps to detect program run time error. iii. Note: This feature of C++ is not supported in Borland Trubo C++
Try Block: The keyword try contains the block of statements surrounded by braces, which may generated and this block of statement is known try block. Catch Block: This block catch the exception (handle) generated in try block, it is thrown in the catch block. Throw statement: When exception is detected, the throw statement sends the control to catch block. (The throw statement exists in try block. When throw statement execute, it pass control to catch block.)
#include #include
class Error { public: void devide(int x, int y) { If(y!=0) { int Result; Result=x/y; cout<<”Result ”<
void main() { try { Error e1; e1.divide(10,0); } catch(int errr) { cout<<”Ececution ”<
Note:- If throw statement do not have any list then this function do not throw any exception.
void test(int x) throw(int, double) { if(x==0) throw ‘x’; else if(x==1) throw 1; else if(x==-1) throw 1.5; } void main() { Try { cout<<”Test throw statement”; test(0); test(1); test(-1); } catch(int i) { cout<<”Integer exception”; } catch(char i) { cout<<”Character exception”; } catch(double i) { cout<<”Double exception”; } } Rethrow Exception: When a throw exception generate an exception and transfer the control to outer try catch block. void divide(int x,int y) { try { if(y==0)
{ throw(y); } else { cout<<”Division : ”x/y; } } catch(int) { throw; } } void main() { try { divide(10,2); divide(20,0); } catch(int) { cout<<”Exception generate”; } cout<<”End of try catch”; }
File Handling: Header file used for file handling is fstream.h. It is a process of storing data into files. File handling transfers data between program and hard disk file. C++ has its own function to access file data and store data into files.
Simple program: void main() { char *name; int roll_no; ofstream fout(“data”); fout<<”Rahul”; fout<<101; fout.close(); ifstream fin(“data”); fin>>name; fin>>roll_no; cout<
File Modes: File modes specify that, how file data will be read and write operation perform. Mode Description ios::in Open file for read only mode. 1. ios::out Open file for writing mode. 2. ios::app Append data to the end of file. 3. ios::ate Write data on the end of file and provide the 4. facility of modifying existing contents. ios::binary Create the binary file. 5. ios::nocreate Open fail if file does not exist. 6. ios::noreplace Open fail if file already exist. 7. ios::trunc Delete all the contents of the file if it exists. It 8. will not create new file. Note: The mode can combine two or more parameter using the bitwise OR (|).
Input and Output Functions for File handling: Put and Get function: i. Put function: The put function writes a single character to the associated stream/file. For Ex: file.put(c) Writes a character c to the output buffer at the current put position and increases the put pointer to point the next character.
ii. Get function: The get function read a single character from the associated stream/file. For Ex: file.get(c) Reads a character c from the current position and increment get pointer to the next character for next data get. Sample program for file handling: #include #include
#include void main() { fstream file; file.open(“data.txt”,ios::in|ios::out); char c[4]={‘a’,’b’,’c’,’d’}, data; for(int i=0;c[i]!=NULL;i++) { file.put(c[i]); } file.seekg(0); cout<<”\n Reading data from file\n”; while(file) { file.get(data); cout<
i. seekg(): Move get pointer to specific location. ii. seekp(): Move put pointer to specific location. iii. tellg(): Give the current position of get pointer.
iv. tellp(): Give the current position of put pointer. Examples: file.tellp(); file.seekg(offset,reference position); file.seekg(0);
Reference Positions ios::beg 0 ios::cur 1 ios::end 2
Error handling in file operation: Error that may occur – i. A file which we are trying to open for reading does not exist. ii. The file name used for a new file may already exist. iii. We may use an invalid file name. iv. There may not any space in the disk for storing more data. Error handling functions for file handling – i. eof(): Return true, if end of file (EOF) is detected while reading a file. Otherwise returns false. ii. bad(): Return true, if an invalid operation has occurred, otherwise false. iii. good(): Return true, if no error has occurred, otherwise return fail. iv. fail(): Return true, when an input or output operation has failed.
STL (Standard Template Library): STL provide a readymade set of common classes for C++. The STL is general purpose classes (Data Structure) and function (Algorithm) that could be used as a standard approach for storing data and processing of data.
Components of STL – 1. Containers: A container is an object that store data. It is a way by which data is organised in memory. The STL containers are implemented by template class and therefore can be easily customized. 2. Algorithms: An algorithm is a procedure that is used to process the data contained in the container. The STL includes many different kind of algorithm to provide support to tasks such as initializing, searching, copying, sorting and merging. Algorithms are implemented by template function. 3. Iterators: An iterator is an object that point to an element in a container. We can use iterator to move through the contents of the container. Iterator can handle the data of container. Iterator connect algorithm with container.
Application of container class – i. Stack ii. Queue iii. Vector iv. DeQue v. List vi. Map
