c Program Full

8/10/2019 c Program Full

1/132

Explain the file handling mechanism of c++?Explain the different modes of file handling?

Give an eg to read and write data to and from a file?

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 outFile("sample.txt"); //output only

ifstream inFile(sample.txt); //input only

OPENING FILE USING open()

Stream-object.open(filename, mode)

ofstream outFile;

outFile.open("sample.txt");

ifstream inFile;inFile.open("sample.txt");

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


2/132

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

outFile.close();

inFile.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 whilereading; 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 anyunrecoverable 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.


3/132

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

Read & Write Example:

Following is the C++ program which opens a file in reading and writing mode. After writinginformation inputted by the user to a file named afile.dat, the program reads information from the

file and outputs it onto the screen:#include #include using namespace std;

int main (){


4/132

char data[100];

// open a file in write mode.ofstream outfile;outfile.open("afile.dat");

cout


5/132

Writing to the fileEnter your name: ZaraEnter your age: 9Reading from the fileZara

How is an Exception Handle in c++? Explain with suitable example?

An exception is a problem that arises during the execution of a program. A C++ exception is aresponse to an exceptional circumstance that arises while a program is running, such as anattempt to divide by zero.Exceptions provide a way to transfer control from one part of a program to another. C++exception handling is built upon three keywords: try, catch,and throw.

throw:A program throws an exception when a problem shows up. This is done usinga throwkeyword.

catch:A program catches an exception with an exception handler at the place in aprogram where you want to handle the problem. The catchkeyword indicates the catching of anexception.

try:A tryblock identifies a block of code for which particular exceptions will beactivated. It's followed by one or more catch blocks.Assuming a block will raise an exception, a method catches an exception using a combination ofthetryand catchkeywords. A try/catch block is placed around the code that might generate anexception. Code within a try/catch block is referred to as protected code, and the syntax for usingtry/catch looks like the following:

try{

// protected code}catch( ExceptionName e1 ){

// catch block}catch( ExceptionName e2 ){

// catch block}catch( ExceptionName eN ){

// catch block}

You can list down multiple catchstatements to catch different type of exceptions in caseyour tryblock raises more than one exception in different situations.

Throwing Exceptions:Exceptions can be thrown anywhere within a code block using throwstatements. The operand ofthe throw statements determines a type for the exception and can be any expression and the typeof the result of the expression determines the type of exception thrown.

Following is an example of throwing an exception when dividing by zero condition occurs:


6/132

double division(int a, int b){

if( b == 0 ){

throw "Division by zero condition!";

}return (a/b);

}

Catching Exceptions:The catchblock following the try block catches any exception. You can specify what type ofexception you want to catch and this is determined by the exception declaration that appears inparentheses following the keyword catch.

try{

// protected code

}catch( ExceptionName e ){

// code to handle ExceptionName exception}

Above code will catch an exception of ExceptionNametype. If you want to specify that a catchblock should handle any type of exception that is thrown in a try block, you must put an ellipsis,..., between the parentheses enclosing the exception declaration as follows:

try{

// protected code

}catch(...){// code to handle any exception

}

The following is an example, which throws a division by zero exception and we catch it in catchblock.

#include using namespace std;

double division(int a, int b)

{if( b == 0 ){

throw "Division by zero condition!";}return (a/b);

}


7/132

int main (){

int x = 50;int y = 0;double z = 0;

try {z = division(x, y);cout


8/132

std::out_of_rangeThis can be thrown by the at method from for example astd::vector and std::bitset::operator[]().

std::runtime_errorAn exception that theoretically can not be detected by readingthe code.

std::overflow_error This is thrown if a mathematical overflow occurs.

std::range_errorThis is occured when you try to store a value which is out ofrange.

std::underflow_error This is thrown if a mathematical underflow occurs.

Define New Exceptions:You can define your own exceptions by inheriting and overriding exceptionclass functionality.Following is the example, which shows how you can use std::exception class to implement yourown exception in standard way:

#include #include using namespace std;

struct MyException : public exception{

const char * what () const throw (){return "C++ Exception";

}};

int main(){try{throw MyException();

}catch(MyException& e){std::cout


9/132

MyException caughtC++ Exception

Here, what()is a public method provided by exception class and it has been overridden by all thechild exception classes. This returns the cause of an exception.

Wap to demonstrate overloading of operator + to add 2 complex number using friend

function?

Some of the most commonly used operators in C++ are the arithmetic operators that is, the

plus operator (+), minus operator (-), multiplication operator (*), and division operator (/). Note

that all of the arithmetic operators are binary operators meaning they take two operands

one on each side of the operator. All four of these operators are overloaded in the exact same

way.

Overloading operators using friend functions

When the operator does not modify its operands, the best way to overload the operator is via

friend function. None of the arithmetic operators modify their operands (they just produce and

return a result), so we will utilize the friend function overloaded operator method here.

The following example shows how to overload operator plus (+) in order to add two Cents

objects together:

Operators can be overloaded in c++ with friend functions also. The procedure is same as wediscussed earlier. Here I will demonstrate operator overloading with "+" operator which is abinary operator. I will be using a complex number class (called complex). The class will have 2data types, real and imaginary.Operator overloading will not be a part of class complex, but we will declare that this function isa friend of class complex.

Note that since overloaded function is not part of class , so will require 2 args (overloading withmember function require 1 arg for binary operator, as the first arg is the object itself.)Use:Most student wonder why we need to use operator overloading in such manner? The answer issimple, this will allow you to manipulate operator for predefined objects that you mat not haveaccess. (Like cout or cin)

Code:#includeusingnamespacestd;// complex class with real and imaginary partclasscomplex{

public:intreal;intimg;//default constructor


10/132

complex(){

real=img=0;}//overloaded constructor with 2 args

complex(intx,inty){real=x;img=y;

}//show function to display complex numbervoidshow(){

cout


11/132

Methods name and signatures must be same. Having same method name with different

Signatures.

Overriding is the concept of runtime

polymorphism

Overloading is the concept of compile time

polymorphism

When a function of base class is re-defined inthe derived class called as Overriding

Two functions having same name and returntype, but with different type and/or number of

arguments is called as Overloading

It needs inheritance. It doesn't need inheritance.

Method should have same data type. Method can have different data types

Method should be public. Method can be different access specifies

Example

Overriding

public class MyBaseClass

{

public virtual void MyMethod()

{

Console.Write("My BaseClass Method");

}

}

public class MyDerivedClass : MyBaseClass{

public override void MyMethod()

{

Console.Write("My DerivedClass Method");

}

}

Overloading

int add(int a, int b)

int add(float a , float b)

Explain the concepts of oops supported by example?


12/132

In this tutorial you will learn about Objects, Classes, Inheritance, Data Abstraction, Data

Encapsulation, Polymorphism, Overloading, and Reusability.

Before starting to learn C++ it is essential to have a basic knowledge of the concepts of Object

oriented programming. Some of the important object oriented features are namely:

Objects

Classes

Inheritance

Data Abstraction

Data Encapsulation

Polymorphism

Overloading

Reusability

In order to understand the basic concepts in C++, a programmer must have a good knowledge ofthe basic terminology in object-oriented programming. Below is a brief outline of the concepts of

object-oriented programming languages :

Objects:

Object is the basic unit of object-oriented programming. Objects are identified by its unique

name. An object represents a particular instance of a class. There can be more than one instance

of a class. Each instance of a class can hold its own relevant data.

An Object is a collection of data members and associated member functions also known asmethods.

Classes:

Classes are data types based on which objects are created. Objects with similar properties and

methods are grouped together to form a Class. Thus a Class represents a set of individual objects.


13/132

Characteristics of an object are represented in a class as Properties. The actions that can be

performed by objects become functions of the class and are referred to as Methods.

For example consider we have a Class of Cars under which Santro Xing, Alto and WaganR

represents individual Objects. In this context each Car Object will have its own, Model, Year of

Manufacture, Color, Top Speed, Engine Power etc., which form Properties of the Car class and

the associated actions i.e., object functions like Start, Move, and Stop form the Methods of Car

Class.

No memory is allocated when a class is created. Memory is allocated only when an object is

created, i.e., when an instance of a class is created.

Inheritance:

Inheritance is the process of forming a new class from an existing class or base class. The base

class is also known as parent class or super class. The new class that is formed is called derived

class. Derived class is also known as a child class or sub class. Inheritance helps in reducing the

overall code size of the program, which is an important concept in object-oriented programming.

Data Abstraction:

Data Abstraction increases the power of programming language by creating user defined data

types. Data Abstraction also represents the needed information in the program without presenting

the details.

Data Encapsulation:

Data Encapsulation combines data and functions into a single unit called Class. When using Data

Encapsulation, data is not accessed directly; it is only accessible through the functions present

inside the class. Data Encapsulation enables the important concept of data hiding possible.

Polymorphism:

Polymorphism allows routines to use variables of different types at different times. An operator

or function can be given different meanings or functions. Polymorphism refers to a single

function or multi-functioning operator performing in different ways.

Overloading:

Overloading is one type of Polymorphism. It allows an object to have different meanings,

depending on its context. When an existing operator or function begins to operate on new data

type, or class, it is understood to be overloaded.


14/132

Reusability:

This term refers to the ability for multiple programmers to use the same written and debugged

existing class of data. This is a time saving device and adds code efficiency to the language.

Additionally, the programmer can incorporate new features to the existing class, further

developing the application and allowing users to achieve increased performance. This timesaving feature optimizes code, helps in gaining secured applications and facilitates easier

maintenance on the application.

The implementation of each of the above object-oriented programming features for C++ will be

highlighted in later sections.

A sample program to understand the basic structure of C++

1. //program to read employee details and to output the data

2.3. ////////// code begins here /////////////////////////////

4. #include< iostream > // Preprocessor directive

5. using namespace std;

6. class employee // Class Declaration

7. {

8. private:

9. char empname[50];

10. int empno;

11.

12. public:

13. void getvalue()

14. {

15. coutempname; //

waiting input from the Keyboard for the name

17. coutempno; // waiting

input from the Keyboard for the number

19. }

20. void displayvalue(){

21. cout


15/132

23.

24. }

25. };

26. void main()

27. {28. employee e1; // Creation of Object

29. e1.getvalue(); // the getvalue method is

being called

30. e1.displayvalue(); // the displayvalue method is being called

31. }

32.

33. ///// code ends here //////////////

Output:

Data Encapsulation

All C++ programs are composed of the following two fundamental elements:

Program statements (code):This is the part of a program that performs actions and theyare called functions.

Program data:The data is the information of the program which affected by theprogram functions.Encapsulation is an Object Oriented Programming concept that binds together the data andfunctions that manipulate the data, and that keeps both safe from outside interference and misuse.

Data encapsulation led to the important OOP concept of data hiding.Data encapsulationis a mechanism of bundling the data, and the functions that use themand data abstractionis a mechanism of exposing only the interfaces and hiding theimplementation details from the user.C++ supports the properties of encapsulation and data hiding through the creation of user-defined types, called classes. We already have studied that a class can contain private,protected and publicmembers. By default, all items defined in a class are private. For example:

class Box


16/132

{public:

double getVolume(void){

return length * breadth * height;

}private:

double length; // Length of a boxdouble breadth; // Breadth of a boxdouble height; // Height of a box

};

The variables length, breadth, and height are private. This means that they can be accessed onlyby other members of the Box class, and not by any other part of your program. This is one wayencapsulation is achieved.To make parts of a class public(i.e., accessible to other parts of your program), you must declarethem after the publickeyword. All variables or functions defined after the public specifier are

accessible by all other functions in your program.

Making one class a friend of another exposes the implementation details and reducesencapsulation. The ideal is to keep as many of the details of each class hidden from all otherclasses as possible.

Data Encapsulation Example:

Any C++ program where you implement a class with public and private members is an exampleof data encapsulation and data abstraction. Consider the following example:


class Adder{public:

// constructorAdder(int i = 0){total = i;

}// interface to outside world

void addNum(int number){

total += number;}// interface to outside worldint getTotal(){

return total;


17/132

};private:

// hidden data from outside worldint total;

};

int main( ){

Adder a;

a.addNum(10);a.addNum(20);a.addNum(30);

cout


18/132

When you define a class, you define a blueprint for a data type. This doesn't actually define anydata, but it does define what the class name means, that is, what an object of the class will consistof and what operations can be performed on such an object.

A class definition starts with the keyword classfollowed by the class name; and the class body,

enclosed by a pair of curly braces. A class definition must be followed either by a semicolon or alist of declarations. For example, we defined the Box data type using the keyword classasfollows:

class Box{

public:double length; // Length of a boxdouble breadth; // Breadth of a boxdouble height; // Height of a box

};

The keyword publicdetermines the access attributes of the members of the class that follow it. A

public member can be accessed from outside the class anywhere within the scope of the classobject. You can also specify the members of a class as privateor protected which we willdiscuss in a sub-section.

Define C++ Objects:

A class provides the blueprints for objects, so basically an object is created from a class. Wedeclare objects of a class with exactly the same sort of declaration that we declare variables ofbasic types. Following statements declare two objects of class Box:

Box Box1; // Declare Box1 of type BoxBox Box2; // Declare Box2 of type Box

Both of the objects Box1 and Box2 will have their own copy of data members.

Accessing the Data Members:

The public data members of objects of a class can be accessed using the direct member accessoperator (.). Let us try the following example to make the things clear:

#include

using namespace std;

class Box{

public:double length; // Length of a boxdouble breadth; // Breadth of a boxdouble height; // Height of a box


19/132

};

int main( ){

Box Box1; // Declare Box1 of type Box

Box Box2; // Declare Box2 of type Boxdouble volume = 0.0; // Store the volume of a box here

// box 1 specificationBox1.height = 5.0;Box1.length = 6.0;Box1.breadth = 7.0;

// box 2 specificationBox2.height = 10.0;Box2.length = 12.0;

Box2.breadth = 13.0;// volume of box 1volume = Box1.height * Box1.length * Box1.breadth;cout


20/132

Class member functions

A member function of a class is a function that has

its definition or its prototype within the class

definition like any other variable.

Class access modifiers A class member can be defined as public, privateor protected. By default members would be

assumed as private.

Constructor & destructor

A class constructor is a special function in a class

that is called when a new object of the class is

created. A destructor is also a special function

which is called when created object is deleted.

C++ copy constructor

The copy constructor is a constructor which

creates an object by initializing it with an object of

the same class, which has been created previously.

C++ friend functions A friendfunction is permitted full access to

private and protected members of a class.

C++ inline functions

With an inline function, the compiler tries to

expand the code in the body of the function in

place of a call to the function.

The this pointer in C++ Every object has a special pointer thiswhich

points to the object itself.

Pointer to C++ classes

A pointer to a class is done exactly the same way a

pointer to a structure is. In fact a class is really just

a structure with functions in it.

Static members of a class Both data members and function members of a

class can be declared as static.

Inheritance

One of the most important concepts in object-oriented programming is that of inheritance.Inheritance allows us to define a class in terms of another class, which makes it easier to create


21/132

and maintain an application. This also provides an opportunity to reuse the code functionalityand fast implementation time.

When creating a class, instead of writing completely new data members and member functions,the programmer can designate that the new class should inherit the members of an existing class.

This existing class is called thebase

class, and the new class is referred to as thederived

class.The idea of inheritance implements the is arelationship. For example, mammal IS-A animal, dogIS-A mammal hence dog IS-A animal as well and so on.

Base & Derived Classes:

A class can be derived from more than one classes, which means it can inherit data and functionsfrom multiple base classes. To define a derived class, we use a class derivation list to specify thebase class(es). A class derivation list names one or more base classes and has the form:

class derived-class: access-specifier base-class

Where access-specifier is one of public, protected,or private, and base-class is the name of a

previously defined class. If the access-specifier is not used, then it is private by default.Consider a base class Shapeand its derived class Rectangleas follows:

#include


// Base classclass Shape{

public:void setWidth(int w){

width = w;}void setHeight(int h){

height = h;}

protected:int width;int height;

};

// Derived classclass Rectangle: public Shape{

public:int getArea(){

return (width * height);


22/132

}};

int main(void){

Rectangle Rect;

Rect.setWidth(5);Rect.setHeight(7);

// Print the area of the object.cout


23/132

When deriving a class from a base class, the base class may be inherited through public,protectedorprivate inheritance. The type of inheritance is specified by the access-specifier asexplained above.We hardly use protectedor privateinheritance, but publicinheritance is commonly used.While using different type of inheritance, following rules are applied:

Public Inheritance:When deriving a class from a publicbase class, publicmembers ofthe base class become publicmembers of the derived class and protectedmembers of the baseclass become protectedmembers of the derived class. A base class's privatemembers are neveraccessible directly from a derived class, but can be accessed through calls tothe publicand protectedmembers of the base class.

Protected Inheritance:When deriving from a protectedbaseclass, publicand protectedmembers of the base class become protectedmembers of the derivedclass.

Private Inheritance:When deriving from a privatebaseclass, publicand protectedmembers of the base class become privatemembers of the derivedclass.

Multiple Inheritances:

A C++ class can inherit members from more than one class and here is the extended syntax:

class derived-class: access baseA, access baseB....

Where access is one of public, protected,or privateand would be given for every base classand they will be separated by comma as shown above. Let us try the following example:

#include


// Base class Shapeclass Shape{

public:void setWidth(int w){

width = w;}void setHeight(int h){

height = h;}


};

// Base class PaintCost


24/132

class PaintCost{

public:int getCost(int area){

return area * 70;}

};

// Derived classclass Rectangle: public Shape, public PaintCost{

public:int getArea(){

return (width * height);

}};

int main(void){

Rectangle Rect;int area;

Rect.setWidth(5);Rect.setHeight(7);

area = Rect.getArea();

// Print the area of the object.cout


25/132

Oveloading Operator & Function

C++ allows you to specify more than one definition for a functionname or an operatorin thesame scope, which is called function overloadingand operator overloadingrespectively.

An overloaded declaration is a declaration that had been declared with the same name as apreviously declared declaration in the same scope, except that both declarations have differentarguments and obviously different definition (implementation).

When you call an overloaded functionor operator, the compiler determines the mostappropriate definition to use by comparing the argument types you used to call the function oroperator with the parameter types specified in the definitions. The process of selecting the mostappropriate overloaded function or operator is called overload resolution.

Function overloading in C++:

You can have multiple definitions for the same function name in the same scope. The definitionof the function must differ from each other by the types and/or the number of arguments in theargument list. You can not overload function declarations that differ only by return type.

Following is the example where same function print()is being used to print different data types:


class printData{

public:void print(int i) {cout


26/132

// Call print to print characterpd.print("Hello C++");

return 0;}

When the above code is compiled and executed, it produces the following result:

Printing int: 5Printing float: 500.263Printing character: Hello C++

Operators overloading in C++:

You can redefine or overload most of the built-in operators available in C++. Thus a programmercan use operators with user-defined types as well.

Overloaded operators are functions with special names the keyword operator followed by thesymbol for the operator being defined. Like any other function, an overloaded operator has areturn type and a parameter list.

Box operator+(const Box&);

declares the addition operator that can be used to add two Box objects and returns final Boxobject. Most overloaded operators may be defined as ordinary non-member functions or as classmember functions. In case we define above function as non-member function of a class then wewould have to pass two arguments for each operand as follows:

Box operator+(const Box&, const Box&);

Following is the example to show the concept of operator over loading using a member function.Here an object is passed as an argument whose properties will be accessed using this object, theobject which will call this operator can be accessed using thisoperator as explained below:


class Box{

public:

double getVolume(void){

return length * breadth * height;}void setLength( double len ){

length = len;}


27/132

void setBreadth( double bre ){

breadth = bre;}

void setHeight( double hei ){

height = hei;}// Overload + operator to add two Box objects.Box operator+(const Box& b){

Box box;box.length = this->length + b.length;box.breadth = this->breadth + b.breadth;

box.height = this->height + b.height;return box;

}private:

double length; // Length of a boxdouble breadth; // Breadth of a boxdouble height; // Height of a box

};// Main function for the programint main( ){

Box Box1; // Declare Box1 of type BoxBox Box2; // Declare Box2 of type BoxBox Box3; // Declare Box3 of type Boxdouble volume = 0.0; // Store the volume of a box here

// box 1 specificationBox1.setLength(6.0);Box1.setBreadth(7.0);Box1.setHeight(5.0);

// box 2 specification

Box2.setLength(12.0);Box2.setBreadth(13.0);Box2.setHeight(10.0);

// volume of box 1volume = Box1.getVolume();cout


28/132

// volume of box 2volume = Box2.getVolume();cout


29/132

C++ polymorphism means that a call to a member function will cause a different function to beexecuted depending on the type of object that invokes the function.

Consider the following example where a base class has been derived by other two classes:


class Shape {protected:

int width, height;public:

Shape( int a=0, int b=0){

width = a;height = b;

}int area(){

cout


30/132

Triangle tri(10,5);

// store the address of Rectangleshape = &rec;// call rectangle area.

shape->area();

// store the address of Triangleshape = &tri;// call triangle area.shape->area();

return 0;}

When the above code is compiled and executed, it produces the following result:

Parent class areaParent class area

The reason for the incorrect output is that the call of the function area() is being set once by thecompiler as the version defined in the base class. This is called static resolutionof the functioncall, orstatic linkage - the function call is fixed before the program is executed. This is alsosometimes calledearly bindingbecause the area() function is set during the compilation of theprogram.But now, let's make a slight modification in our program and precede the declaration of area() inthe Shape class with the keyword virtualso that it looks like this:

class Shape {protected:int width, height;

public:Shape( int a=0, int b=0){


}virtual int area(){

cout


31/132

Rectangle class areaTriangle class area

This time, the compiler looks at the contents of the pointer instead of it's type. Hence, sinceaddresses of objects of tri and rec classes are stored in *shape the respective area() function is

called.

As you can see, each of the child classes has a separate implementation for the function area().This is how polymorphismis generally used. You have different classes with a function of thesame name, and even the same parameters, but with different implementations.

Virtual Function:

A virtual function is a function in a base class that is declared using the keyword virtual.Defining in a base class a virtual function, with another version in a derived class, signals to thecompiler that we don't want static linkage for this function.What we do want is the selection of the function to be called at any given point in the program tobe based on the kind of object for which it is called. This sort of operation is referred toas dynamic linkage, or late binding.

Pure Virtual Functions:

It's possible that you'd want to include a virtual function in a base class so that it may beredefined in a derived class to suit the objects of that class, but that there is no meaningfuldefinition you could give for the function in the base class.

We can change the virtual function area() in the base class to the following:

class Shape {

protected:int width, height;public:

Shape( int a=0, int b=0){


}// pure virtual functionvirtual int area() = 0;

};

The = 0 tells the compiler that the function has no body and above virtual function will becalled pure virtual function.

Data Abstraction


32/132

Data abstraction refers to, providing only essential information to the outside world and hidingtheir background details, i.e., to represent the needed information in program without presentingthe details.

Data abstraction is a programming (and design) technique that relies on the separation of

interface and implementation.Let's take one real life example of a TV, which you can turn on and off, change the channel,adjust the volume, and add external components such as speakers, VCRs, and DVD players,BUT you do not know its internal details, that is, you do not know how it receives signals overthe air or through a cable, how it translates them, and finally displays them on the screen.

Thus, we can say a television clearly separates its internal implementation from its externalinterface and you can play with its interfaces like the power button, channel changer, and volumecontrol without having zero knowledge of its internals.

Now, if we talk in terms of C++ Programming, C++ classes provides great level of data

abstraction. They provide sufficient public methods to the outside world to play with thefunctionality of the object and to manipulate object data, i.e., state without actually knowing howclass has been implemented internally.For example, your program can make a call to the sort()function without knowing whatalgorithm the function actually uses to sort the given values. In fact, the underlyingimplementation of the sorting functionality could change between releases of the library, and aslong as the interface stays the same, your function call will still work.In C++, we use classesto define our own abstract data types (ADT). You can use the coutobjectof class ostreamto stream data to standard output like this:


int main( ){

cout


33/132

There are no restrictions on how often an access label may appear. Each access label specifiesthe access level of the succeeding member definitions. The specified access level remains ineffect until the next access label is encountered or the closing right brace of the class body isseen.

Benefits of Data Abstraction:

Data abstraction provides two important advantages:

Class internals are protected from inadvertent user-level errors, which might corrupt thestate of the object.

The class implementation may evolve over time in response to changing requirements orbug reports without requiring change in user-level code.

By defining data members only in the private section of the class, the class author is free to makechanges in the data. If the implementation changes, only the class code needs to be examined to

see what affect the change may have. If data are public, then any function that directly accessesthe data members of the old representation might be broken.

Data Abstraction Example:

Any C++ program where you implement a class with public and private members is an exampleof data abstraction. Consider the following example:


class Adder{public:

// constructorAdder(int i = 0){total = i;

}// interface to outside worldvoid addNum(int number){

total += number;

}// interface to outside worldint getTotal(){

return total;};

private:// hidden data from outside world


34/132

int total;};int main( ){

Adder a;

a.addNum(10);a.addNum(20);a.addNum(30);

cout


35/132

public:// pure virtual functionvirtual double getVolume() = 0;

private:double length; // Length of a box

double breadth; // Breadth of a boxdouble height; // Height of a box

};

The purpose of an abstract class(often referred to as an ABC) is to provide an appropriate baseclass from which other classes can inherit. Abstract classes cannot be used to instantiate objectsand serves only as an interface. Attempting to instantiate an object of an abstract class causes acompilation error.

Thus, if a subclass of an ABC needs to be instantiated, it has to implement each of the virtualfunctions, which means that it supports the interface declared by the ABC. Failure to override apure virtual function in a derived class, then attempting to instantiate objects of that class, is a

compilation error.

Classes that can be used to instantiate objects are called concrete classes.

Abstract Class Example:

Consider the following example where parent class provides an interface to the base class toimplement a function called getArea():

#include


// Base classclass Shape{public:

// pure virtual function providing interface framework.virtual int getArea() = 0;void setWidth(int w){

width = w;}void setHeight(int h)

{ height = h;}


};


36/132

// Derived classesclass Rectangle: public Shape{public:

int getArea()

{return (width * height);

}};class Triangle: public Shape{public:

int getArea(){

return (width * height)/2;}

};

int main(void){

Rectangle Rect;Triangle Tri;

Rect.setWidth(5);Rect.setHeight(7);// Print the area of the object.cout


37/132

An object-oriented system might use an abstract base class to provide a common andstandardized interface appropriate for all the external applications. Then, through inheritancefrom that abstract base class, derived classes are formed that all operate similarly.

The capabilities (i.e., the public functions) offered by the external applications are provided as

pure virtual functions in the abstract base class. The implementations of these pure virtualfunctions are provided in the derived classes that correspond to the specific types of theapplication.

This architecture also allows new applications to be added to a system easily, even after thesystem has been defined.

Explain the new and delete operator in dynamic memory allocation?

A good understanding of how dynamic memory really works in C++ is essential to becoming agood C++ programmer. Memory in your C++ program is divided into two parts:

The stack:All variables declared inside the function will take up memory from the stack. The heap:This is unused memory of the program and can be used to allocate the

memory dynamically when program runs.

Many times, you are not aware in advance how much memory you will need to store particularinformation in a defined variable and the size of required memory can be determined at run time.

You can allocate memory at run time within the heap for the variable of a given type using aspecial operator in C++ which returns the address of the space allocated. This operator is

called newoperator.If you are not in need of dynamically allocated memory anymore, you can use deleteoperator,which de-allocates memory previously allocated by new operator.

The new and delete operators:

There is following generic syntax to use newoperator to allocate memory dynamically for anydata-type.

new data-type;

Here, data-typecould be any built-in data type including an array or any user defined data typesinclude class or structure. Let us start with built-in data types. For example we can define apointer to type double and then request that the memory be allocated at execution time. We can

do this using the newoperator with the following statements:double* pvalue = NULL; // Pointer initialized with nullpvalue = new double; // Request memory for the variable

The memory may not have been allocated successfully, if the free store had been used up. So it isgood practice to check if new operator is returning NULL pointer and take appropriate action asbelow:


38/132

double* pvalue = NULL;if( !(pvalue = new double )){

cout


39/132

pvalue = new char[20]; // Request memory for the variable

To remove the array that we have just created the statement would look like this:

delete [] pvalue; // Delete array pointed to by pvalue

Following the similar generic syntax of new operator, you can allocat for a multi-dimensionalarray as follows:

double** pvalue = NULL; // Pointer initialized with nullpvalue = new double [3][4]; // Allocate memory for a 3x4 array

However, the syntax to release the memory for multi-dimensional array will still remain same asabove:

delete [] pvalue; // Delete array pointed to by pvalue

Dynamic Memory Allocation for Objects:

Objects are no different from simple data types. For example, consider the following code wherewe are going to use an array of objects to clarify the concept:


class Box{

public:Box() {

cout


40/132

If you were to allocate an array of four Box objects, the Simple constructor would be called fourtimes and similarly while deleting these objects, destructor will also be called same number oftimes.

If we compile and run above code, this would produce the following result:

Constructor called!Constructor called!Constructor called!Constructor called!Destructor called!Destructor called!Destructor called!Destructor called!

Wap to read 2 integer from keyboard and to perform simple airthematic operation using

the pointer technique?The memory space for the operator is allocated by the new

operator?

Wap a program to define a class vector that operates on vector. write the member function

to compute the vector product, scalar product ,sum of the element of the vector, average of

elements, and sum of the square of elements?

What is containership? How does it differ from inheritance?

Inheritance vs Containership

Inheritance and Containership are two important concepts found in OOP (Object Oriented

Programming Example: C++). In simple terms, both Containership and Inheritance deal with

providing additional properties or behavior to a class. Inheritance is the ability for a class to

inherit properties and behavior from a parent class by extending it. On the other hand,

Containership is the ability of a class to contain objects of different classes as member data.

What is Inheritance?

As mentioned above, Inheritance is the ability for a class to inherit properties and behavior from

a parent class by extending it. Inheritance essentially provides code reuse by allowing extending

properties and behavior of an existing class by a newly defined class. If class A extends B, then

class B is called the parent class (or super class) and class A is called the child class (or derived


41/132

class/sub class). In this example scenario, class A will inherit all public and protected attributes

and methods of the super class (B). The subclass can optionally override (provide new or

extended functionality to methods) the behavior inherited from the parent class. Inheritance

represents an is-a relationship in OOP. This essentially means that A is also a B. In other

words, B can be the class with a general description of a certain real world entity but A specifies

a certain specialization. In a real world programming problem, the Person class could be

extended to create the Employee class. This is called specialization. But you could also first

create the Employee class and then generalize it to a Person class as well (i.e. generalization). In

this example, the Employee will have all the properties and behavior of the Person (i.e.

Employee is also a Person) and may contain some additional functionality (so, Person is not an

Employee) as well.

What is Containership?

Containership is the ability of a class to contain objects of different classes as member data. Forexample, class A could contain an object of class B as a member. Here, all the public methods

(or functions) defined in B can be executed within the class A. Class A becomes the container,

while class B becomes the contained class. Containership is also referred to as Composition. In

this example, it can be said that class A is composed of class B. In OOP, Containership

represents a has-a relationship. It is important to note that, even though the container has

access to execute all the public methods of the contained class, it is not able to alter or provide

additional functionality. When it comes to a real world programming problem, an object of class

TextBox may be contained in the class Form, and thus can be said that a Form contains a

TextBox (or alternatively, a Form is composed of a TextBox).

Difference between Inheritance and Containership

Although Inheritance and Containership are two OOP concepts, they are quite different in what

they allow the programmer to achieve. Inheritance is the ability for a class to inherit properties

and behavior from a parent class by extending it, while Containership is the ability of a class to

contain objects of different classes as member data. If a class is extended, it inherits all the public

and protected properties/behavior and those behaviors may be overridden by the subclass. But if

a class is contained in another, the container does not get the ability to change or add behavior to

the contained. Inheritance represents an is-a relationship in OOP, while Containership

represents a has-a relationship.

Differentiate between class and Objects?

Objects vs Classes


42/132

Objects and classes are used in object oriented programming languages. All object oriented

programming languages such as C++, Java, .NET and others, employs objects and classes.

Objects

An object is defined as any entity that can be utilized by using commands in a programming

language. Object can be a variable, value, data structure or a function. In object oriented

environment, object is referred to as instance of a class. Objects and classes are closely related to

each other. In real world, the objects are your TV, bicycle, desk and other entities. Methods are

used to access the objects of a class. All the interaction is done through the objects methods.

This is known as data encapsulation. The objects are also used for data or code hiding.

A number of benefitsareprovided by the objects when they are used in the code:

Ease of debugging The object can be easily removed from the code if there is some problem

due to it. A different object can be plugged in as a replacement of the former one. Information hiding The code or internal implementation is hidden from the users when

interaction is done through objects methods.

Reuse of code if an object or code is written by some other programmer then you can also use

that object in your program. In this way, objects are highly reusable. This allows experts to

debug, implement task specific and complex objects that can be used in your own code.

Modularity You can write as well as maintain the source codes of objects in an independent

manner. This provides modular approach to programming.

Classes

A class is a concept used in object oriented programming languages such as C++, PHP, andJAVA etc. Apart from holding data, a class is also used to hold functions. An object is an instant

of a class. In case of variables, the type is the class whereas the variable is the object. The

keyword class is used to declare a class and it has the following format:

class CLASS_NAME

{

AccessSpecifier1:

Member-1;

AccessSpecifier2:

Member-2;

} OBJECT_NAMES;

Here, the valid identifier is CLASS_NAME and the names for objects are represented by

OBJECT_NAMES. The benefit of objects include information hiding, modularity, ease in

debugging and reuse of the code. The body contains the members that can be functions or data

declarations. The keywords for access specifiers are public, protected or private.


43/132

The public members can be accessed anywhere.

The protected members can be accessed within same classes or from friend classes.

The private members can be accessed only within the same class.

By default, the access is private when the class keyword is used. A class can hold both data and

functions.

Objects vs. Classes

An object is an instant of a class. A class is used to hold data and functions.

When a class is declared, no memory is allocated but when the object of the class is

declared, memory is allocated. So, class is just a template.

An object can only be created if the class is already declared otherwise it is not possible

Difference between containership and inheritance or derived class in C++

Containership: Containership is the phenomenon of using one or more classes within the

definition of other class. When a class contains the definition of some other classes, it is referred

to as composition, containment or aggregation. The data member of a new class is an object of

some other class. Thus the other class is said to be composed of other classes and hence referred

to as containership. Composition is often referred to as a has-a relationship because the

objects of the composite class have objects of the composed class as members.

What is a container class? What are the types of container classes?

A container class is a class that is used to hold objects in memory or external storage. A

container class acts as a generic holder. A container class has a predefined behavior and a well-

known interface. A container class is a supporting class whose purpose is to hide the topology

used for maintaining the list of objects in memory. When a container class contains a group of

mixed objects, the container is called a heterogeneous container; when the container is holding a

group of objects that are all the same, the container is called a homogeneous container.

Inheritance: Inheritance is the phenomenon of deriving a new class from an old one.

Inheritance supports code reusability. Additional features can be added to a class by deriving aclass from it and then by adding new features to it. Class once written or tested need not be

rewritten or redefined. Inheritance is also referred to as specialization or derivation, as one class

is inherited or derived from the other. It is also termed as is-a relationship because every

object of the class being defined is also an object of the inherited class.


44/132

How is polymorphism achieved in compile time and runtime?

Compile time Polymorphism:

C++ support polymorphism. One function multiple purpose, or in short many functions havingsame name but with different function body.For every function call compiler binds the call to one function definition at compile time. This

decision of binding among several functions is taken by considering formal arguments of thefunction, their data type and their sequence.

Example of compile time polymorphism:

Example 1: example of compile time polymorphism; static time binding

void f(int i){cout


45/132

class Derv: public Base{public:

void display(int j){ cout


46/132

an integer expression. The switch selection structure is a multiple selection structure, it selectsthe action to perform from many different action states.

C++ provides three types of repetition structures also called looping structures or loops,namely while, do/while, and for. A repetition structure allows the programmer to specify that a

program should repeat an action while some condition remains true.posted by Carlos @ 1:30 PM

If Selection StructurePrograms use selection structures to choose among alternative courses of action. For example,suppose the passing grade on exam is 60. The pseudo code statement

If students grade is greater than or equal to 60

Print Passed

Determines whether the condition "students" grade is greater than or equal to 60 is true or false.If the condition is true, then "Passed" If the condition is false the print statement is ignored.Example as followsIf single selection structure activity diagram

posted by Carlos @ 1:29 AM

if/else selection structureThe ifselection structure performs an indicated action only when the condition is true otherwisethe action is skipped. The if/elseselection structure allows the programmer to specify an actionto perform when the condition is true and a different action to perform when the condition isfalse. For example, the pseudo code statement.


47/132

If students grade is greater than or equal to 60Print Passed

else

Print Failed

Print Passed if the student's grade is greater than or equal to 60, but prints Failed if thestudent's grade is less than 60. In either case, after printing occurs. the next pseudo codestatement in sequence is performed.

Example as followsif/else double selection structure activity diagram


switch Multiple Selection StructureOccasionally, an algorithm will contain a series of decision in which a variable or expression is

tested separately for each of the constant integral values it can assume and different actions aretaken. C++ provides the switch multiple selection structure to handle such decision making. Theswitch structure consists of a series of case labels and an optional default case

Example as followsSwitc selection structure activity diagram.


48/132


while Repetition StructureA repetition structure allows the programmer to specify that a program should repeat an actionwhile some condition remains true. The pseudo code statement

While there are more items on my shopping list

Purchase next item and cross it off my list

Describes the repetition that occurs during a shopping trip. The condition there are more items onmy shopping list is either true or false. if it is true, then the action purchase next item and cross itoff list is performed. This action will be performed repeatedly while the condition remains true.Example as followswhile repetition structure activity diagram


for Repetition Structure


49/132

The general format of theforstructure is

for ( initialization; loopContinuationCondition; increment)

Statement

Where the initialization expression initializes the loop control variable, loopContinuation is thecondition that determines whether the loop should continue executing, and increment incrementsthe control variable. In most cases, the for structure can be represented by an equivalent whilestructure, as follows:

Initialization;

while ( loop Continuation Condition) {

statement

increment;

}Example as follows

for repetition structure activity diagram


do/while Repetition StructureThe do/whilerepetition structure is similar to the while structure. In thewhilestructure, the loopcontinuation condition test occurs at the beginning of the loop before the body of the loopexecutes. The do/whilestructure tests the loop continuation condition after the loop executestherefore, the loop body executes at least once. When a do/whileterminates, execution continueswith the statement after the while clause. Note that it is not necessary to use braces inthe do/whilestructure if there is only one statement in the body. Howeve, most programmersinclude the braces to avoid confusion between the while and do/while structures. For example

while ( condition)

Normally is regarded as the header to a while structure. A do/while with no braces around thesingle statement body appears as

dostatementwhile ( condition );

which can be confusing. The line while (condition); might be misinterpreted by the reader as a


50/132

while structure containing an empty statement. Thus, the do/while with one statement is oftenwritten as follows to avoid confusion;

do {statement

} while (condition);Example as followsdo/while repetition structure activity diagram


CONTROL STRUCTURES QUIZProblem Task: Write a program to get the marks obtained from a subject by a student andcalculate the avarage grade for that particular subject?

Here is a piece of pheudocode to help you with your answer

If student's grade is greater than or equal to 90Print "A"else

If student's grade is greater than or equal to 80Print "B"else

If student's grade is greater than or equal to 70Print "C"else

If student's grade is greater than or equal to 60Print "D"else

Print "F"

What does this pointer point to ? what are its application?


51/132

Every object in C++ has access to its own address through an important pointercalled thispointer. Thethispointer is an implicit parameter to all member functions. Therefore,inside a member function, this may be used to refer to the invoking object.Friend functions do not have a thispointer, because friends are not members of a class. Onlymember functions have a thispointer.

Let us try the following example to understand the concept of this pointer:

#include


class Box{

public:// Constructor definitionBox(double l=2.0, double b=2.0, double h=2.0){

cout


52/132

{cout


53/132

Remember that the values those are Passed to the Functions will never effect the Actual Values

those are Stored into the variables.

2) Call By Reference :-When a function is called by the reference then the values those arepassed in the calling functions are affected when they are passed by Reference Means they

change their value when they passed by the References. In the Call by Reference we pass the

Address of the variables whose Arguments are also Send. So that when we use the Reference

then, we pass the Address the Variables.

When we pass the Address of variables to the Arguments then a Function may effect on the

Variables. Means When a Function will Change the Values then the values of Variables gets

Automatically Changed. And When a Function performs Some Operation on the Passed values,then this will also effect on the Actual Values.


54/132

Multiple Inheritances?

Multiple Inheritance in C++

Multiple Inheritance is a feature of C++ where a class can inherit from more than one classes.

The constructors of inherited classes are called in the same order in which they are inherited. For

example, in the following program, Bs constructor is called before As constructor.

#include


class A


55/132

{

public:

A() { cout


56/132

For example, consider the following program.

#include


class Person {

// Data members of person

public:

Person(int x) { cout


57/132

class TA : public Faculty, public Student {

public:

TA(int x):Student(x), Faculty(x) {

cout


58/132

};


public:


cout


59/132

Student(int x):Person(x) {

cout


60/132

class C: public A

{

public:

C() { setX(20); }

};

class D: public B, public C {

};

int main()

{

D d;

d.print();

return 0;}

Question 2

#include


class A

{

int x;

public:

A(int i) { x = i; }void print() { cout


61/132

class D: public B, public C {

};

int main()

{

D d;

d.print();

return 0;

}

What is a friend function? What are its merits and demerits of using a friend function?

A friend function of a class is defined outside that class' scope but it has the right to access allprivate and protected members of the class. Even though the prototypes for friend functionsappear in the class definition, friends are not member functions.

A friend can be a function, function template, or member function, or a class or class template, inwhich case the entire class and all of its members are friends.

To declare a function as a friend of a class, precede the function prototype in the class definitionwith keyword friendas follows:

class Box{

double width;public:

double length;

friend void printWidth( Box box );void setWidth( double wid );

};

To declare all member functions of class ClassTwo as friends of class ClassOne, place afollowing declaration in the definition of class ClassOne:

friend class ClassTwo;

Consider the following program:

#include


class Box{

double width;public:


62/132

friend void printWidth( Box box );void setWidth( double wid );

};

// Member function definition

void Box::setWidth( double wid ){

width = wid;}

// Note: printWidth() is not a member function of any class.void printWidth( Box box ){

/* Because printWidth() is a friend of Box, it candirectly access any member of this class */

cout


63/132

The major disadvantage of friend functions is that they require an extra line of code when youwant dynamic binding. To get the effect of a virtual friend, the friend function should call ahidden (usually protected) virtual member function. This is called the Virtual Friend FunctionIdiom. For example:

class Base {public:

friend void f(Base& b);...

protected:virtual void do_f();...

};

inline void f(Base& b){

b.do_f();}

class Derived : public Base {public:

...protected:

virtual void do_f(); // "Override" the behavior of f(Base& b)...

};

void userCode(Base& b){

f(b);}

The statement f(b) in userCode(Base&) will invoke b.do_f(), which is virtual. This meansthat Derived::do_f() will get control if b is actually a object of class Derived. Notethat Derivedoverrides the behavior of the protected virtual member function do_f(); itdoes nothave its own variation of the friend function, f(Base&).

Difference between function prototyping and function overloading?

In C++ all functions must be declared before they are used. This is accomplished using functionprototype. Prototypes enable complier to provide stronger type checking. When prototype isused, the compiler can find and report any illegal type conversions between the type ofarguments used to call a function and the type definition of its parameters. It can also find thedifference between the no of arguments used to call a function and the number of parameters in


64/132

the function. Thus function prototypes help us trap bugs before they occur. In addition, they helpverify that your program is working correctly by not allowing functions to be called withmismatched arguments.

A general function prototype looks like following:

return_type func_name(type param_name1, type param_name2, ,type param_nameN);The type indicates data type. parameter names are optional in prototype.

Following program illustrates the value of function parameters:

void sqr_it(int *i); //prototype of function sqr_itint main(){

int num;num = 10;sqr_it(num); //type mismatch

return 0;}

void sqr_it(int *i){

*i = *i * *i;}Since sqr_it() has pointer to integer as its parameter, the program throws an error when we passan integer to it.

C++ function overloading programs

Function overloading in C++: C++ program for function overloading. Function overloading

means two or more functions can have the same name but either the number of arguments or the

data type of arguments has to be different. Return type has no role because function will return a

value when it is called and at compile time compiler will not be able to determine which function

to call. In the first example in our code we make two functions one for adding two integers and

other for adding two floats but they have same name and in the second program we make two

functions with identical names but pass them different number of arguments. Function

overloading is also known as compile time polymorphism.

C++ programming code

#include


/* Function arguments are of different data type */


65/132

long add(long, long);float add(float, float);

int main(){

long a, b, x;float c, d, y;

cout > a >> b;

x = add(a, b);

cout d;

y = add(c, d);

cout


66/132

code of functions is same except data type, C++ provides a solution to this problem we can

create a single function for different data types which reduces code size which is via templates.

C++ programming code for function overloading

#include


/* Number of arguments are different */

void display(char []); // print the string passed as argumentvoid display(char [], char []);

int main(){

char first[] = "C programming";

char second[] = "C++ programming";

display(first);display(first, second);

return 0;}

void display(char s[]){

cout


67/132

Opening a file using constructor

This involves two steps

1. Create file stream subject to manage the stream using the appropriate class. That is the class

ofstream is used to create the output stream and the class ifstream to create the input stream.

2. Initialize the file object with the desired filename.

Syntax:

Ofstream object(file_name);

Example:

Ofstream obj(sample.doc)

This creates obj1 as an ofstream that manages the output stream.

#include stream.h

#include string.hVoid main()

{

char str[]=ssi computer center;

ofstream outfile(sample.doc);

for(int j=0;jSyntax:

Ifstream object (file_name);

Example:

Ifstream obj(sample.doc)

This creates obj1 as an ifstream that manages the input stream.

#include fstream.h

void main()

{

char ch;

ifstream in(sample.txt);

while(!in.eof())

{

in.get(ch);

cout


68/132

const int MAX=80;

char buffer[MAX];

ifstream infile(sample.txt);

while(!infile.eof())

{

infile.getline(buffer, MAX);

cout


69/132

}

// if successful creating/opening the file

else

{

cout


70/132

Standard Template Library

STL The C++ STL (Standard Template Library) is a powerful set of C++ template classes to

provide general-purpose templatized classes and functions that implement many popular and

commonly used algorithms and data structures like vectors, lists, queues, and stacks. The STL

is a set of abstract data-types, functions, and algorithms designed to handle user-specified data-

types The Standard Template Library is the idea of generic programming o The implementation

of algorithms or data structures without being dependent on the type of data being handled

Subject Teacher: Shubhashree Savant Page 23 The STL is a generic library, meaning that its

components are heavily parameterized: o almost every component in the STL is a template STL

is divided into three parts namely containers, algorithms, and iterators o All these three parts can

be used for different programming problems At the core of the C++ Standard Template Library

are following three wellstructured components: Component Description Containers Containersare used to manage collections of objects of a certain kind. There are several different types of

containers like deque, list, vector, map etc. Algorithms Algorithms act on containers. They

provide the means by which you will perform initialization, sorting, searching, and transforming

of the contents of containers. Iterators Iterators are used to step through the elements of

collections of objects. These collections may be containers or subsets of containers.

Hope you already understand the concept of C++ Template which we already have discussed inone of the chapters. The C++ STL (Standard Template Library) is a powerful set of C++template classes to provides general-purpose templatized classes and functions that implementmany popular and commonly used algorithms and data structures like vectors, lists, queues, andstacks.

At the core of the C++ Standard Template Library are following three well-structuredcomponents:

Component Description

ContainersContainers are used to manage collections of objects of acertain kind. There are several different types of containerslike deque, list, vector, map etc.

AlgorithmsAlgorithms act on containers. They provide the means bywhich you will perform initialization, sorting, searching,and transforming of the contents of containers.

IteratorsIterators are used to step through the elements ofcollections of objects. These collections may be containersor subsets of containers.


71/132

We will discuss about all the three C++ STL components in next chapter while discussing C++Standard Library. For now, keep in mind that all the three components have a rich set of pre-defined functions which help us in doing complicated tasks in very easy fashion.

Let us take the following program demonstrates the vector container (a C++ Standard Template)

which is similar to an array with an exception that it automatically handles its own storagerequirements in case it grows:

#include #include using namespace std;

int main(){

// create a vector to store intvector vec;

int i;

// display the original size of veccout


72/132

vector size = 0extended vector size = 5value of vec [0] = 0value of vec [1] = 1value of vec [2] = 2

value of vec [3] = 3value of vec [4] = 4value of v = 0value of v = 1value of v = 2value of v = 3value of v = 4

Here are following points to be noted related to various functions we used in the above example:

The push_back( ) member function inserts value at the end of the vector, expanding its

size as needed.

The size( ) function displays the size of the vector.

The function begin( ) returns an iterator to the start of the vector.

The function end( ) returns an iterator to the end of the vector.

Function Template

Templates are the foundation of generic programming, which involves writing code in a way thatis independent of any particular type.

A template is a blueprint or formula for creating a generic class or a function. The librarycontainers like iterators and algorithms are examples of generic programming and have beendeveloped using template concept.

There is a single definition of each container, such as vector, but we can define many differentkinds of vectors for example, vector or vector .

You can use templates to define functions as well as classes, let us see how do they work:

Function Template:

The general form of a template function definition is shown here:

template ret-type func-name(parameter list)


73/132

{// body of function

}

Here, type is a placeholder name for a data type used by the function. This name can be used

within the function definition.

The following is the example of a function template that returns the maximum of two values:

#include #include


template inline T const& Max (T const& a, T const& b)

{return a < b ? b:a;

}int main (){

int i = 39;int j = 20;cout


74/132

Just as we can define function templates, we can also define class templates. The general form ofa generic class declaration is shown here:

template class class-name {.

.

.}

Here, type is the placeholder type name, which will be specified when a class is instantiated.You can define more than one generic data type by using a comma-separated list.

Following is the example to define class Stack and implement generic methods to push andpop the elements from the stack:

#include #include

#include #include #include


template class Stack {private:

vector elems; // elements

public:void push(T const&); // push elementvoid pop(); // pop elementT top() const; // return top elementbool empty() const{ // return true if empty.

return elems.empty();}

};

template void Stack::push (T const& elem)

{// append copy of passed elementelems.push_back(elem);

}

template void Stack::pop (){


75/132

if (elems.empty()) {throw out_of_range("Stack::pop(): empty stack");

}// remove last element

elems.pop_back();

}

template T Stack::top () const{

if (elems.empty()) {throw out_of_range("Stack::top(): empty stack");

}// return copy of last element

return elems.back();}

int main(){

try {Stack intStack; // stack of intsStack stringStack; // stack of strings

// manipulate int stackintStack.push(7);cout


76/132

[This section corresponds to K&R Sec. 7.5]

How will we specify that we want to access a particular data file? It would theoretically bepossible to mention the name of a file each time it was desired to read from or write to it. Butsuch an approach would have a number of drawbacks. Instead, the usual approach (and the one

taken in C's stdio library) is that you mention the name of the file once, at the time you openit.Thereafter, you use some little token--in this case, thefile pointer--which keeps track (both foryour sake and the library's) of which file you're talking about. Whenever you want to read fromor write to one of the files you're working with, you identify that file by using its file pointer(that is, the file pointer you obtained when you opened the file). As we'll see, you store filepointers in variables just as you store any other data you manipulate, so it is possible to haveseveral files open, as long as you use distinct variables to store the file pointers.

You declare a variable to store a file pointer like this:

FILE *fp;

The type FILE is predefined for you by . It is a data structure which holds theinformation the standard I/O library needs to keep track of the file for you. For historical reasons,you declare a variable which is a pointer to this FILE type. The name of the variable can (as forany variable) be anything you choose; it is traditional to use the letters fp in the variable name(since we're talking about a file pointer). If you were reading from two files at once you'dprobably use two file pointers:

FILE *fp1, *fp2;If you were reading from one file and writing to another you might declare and input file pointerand an output file pointer:

FILE *ifp, *ofp;

Like any pointer variable, a file pointer isn't any good until it's initialized to point to something.(Actually, no variable of any type is much good until you've initialized it.) To actually open afile, and receive the ``token'' which you'll store in your file pointer variable, youcall fopen. fopen accepts a file name (as a string) and a modevalue indicating among otherthings whether you intend to read or write this file. (The mode variable is also a string.) To openthe file input.dat for reading you might call

ifp = fopen("input.dat", "r");The mode string "r" indicates reading. Mode "w" indicates writing, so we couldopen output.dat for output like this:

ofp = fopen("output.dat", "w");The other values for the mode string are less frequently used. The third major mode is "a" forappend. (If you use "w" to write to a file which already exists, its old contents will be discarded.)You may also add a +character to the mode string to indicate that you want to both read andwrite, or a b character to indicate that you want to do ``binary'' (as opposed to text) I/O.

One thing to beware of when opening files is that it's an operation which may fail. The requestedfile might not exist, or it might be protected against reading or writing. (These possibilities oughtto be obvious, but it's easy to forget them.) fopen returns a null pointer if it can't open the


77/132

requested file, and it's important to check for this case before going off and using fopen's returnvalue as a file pointer. Every call to fopen will typically be followed with a test, like this:

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

{printf("can't open file\n");exit or return}

If fopen returns a null pointer, and you store it in your file pointer variable and go off and try todo I/O with it, your program will typically crash.

It's common to collapse the call to fopen and the assignment in with the test:

if((ifp = fopen("input.dat", "r")) == NULL){

printf("can't open file\n");exit or return}

You don't have to write these ``collapsed'' tests if you're not comfortable with them, but you'll

see them in other people's code, so you should be able to read them

Differnce between multiple and multilevel inheriatnace?

Multilevel Inheritance

When a class is derived form another derived class is called multilevel inheritance. In the

following figure the class A serves as a base class for the derived class B, which in turn serves as

a base class for the derived class C/ the class B is known as intermediate base class since it

provides a link for the inheritance between A and C. the chain ABC is known as inheritance

path.

class A{}; //Base Class

class B: public A{}; // B derived from A

class C: public B{}; // C derived from B


78/132

Example:

#include

#include

class Student //Base Class

{protected:

int rno;

public:

void get_number(int);

void put_number(void);

};

void Student::get_number(int a){ rno = a; }

void Student::put_number(void)

{

cout


79/132

void put_marks(void);

};

void Test::get_marks(int x, int y)

{

sub1 = x;

sub2 = y;

}

void Test::put_marks(void)

{

cout


80/132

.

Multiple Inheritance in C++

Multiple Inheritance is a feature of C++ where a class can inherit from more than one classes.

The constructors of inherited classes are called in the same order in which they are inherited. For

example, in the following program, Bs constructor is called before As constructor.

#include


class A

{

public:

A() { cout


81/132

example, in the following diagram, the TA class gets two copies of all attributes of Person class,

this causes ambiguities.

For example, consider the following program.

#include


class Person {

// Data members of person

public:

Person(int x) { cout


82/132

};


public:


cout


83/132


cout


84/132

};

class Student : virtual public Person {

public:


cout


85/132

};

/* class C is multiple derived from its superclass A and B */class C:public A, public B

{};

int main(){

C c;c.show();

}

Ambiguous call:

For the above sample program, c.show() is ambiguousto get resolved among candidatefunctionsB::show() and A::show()

Solution to ambiguous calls in multiple inheritance:

Use scope resolution operator to explicitly specify which base class's member function is to beinvoked.

Like, c.A::show();

What is a copy constructor & when it is invocked? Wap with a class Abc and one integer

data type member?overload the copy constructor and assignment operator for the class? A copy constructor is a member function which initializes an object using another object of thesame class. A copy constructor has the following general function prototype:

ClassName (const ClassName &old_obj);

Following is a simple example of copy constructor.

#include


class Point{private:

int x, y;public:

Point(int x1, int y1) { x = x1; y = y1; }


86/132

// Copy constructorPoint(const Point &p2) {x = p2.x; y = p2.y; }

int getX() { return x; }

int getY() { return y; }};

int main(){

Point p1(10, 15); // Normal constructor is called herePoint p2 = p1; // Copy constructor is called here

// Let us access values assigned by constructorscout


87/132

Copy constructor vs Assignment OperatorWhich of the following two statements call copy constructor and which one calls assignmentoperator?

MyClass t1, t2;

MyClass t3 = t1; // ----> (1)t2 = t1; // -----> (2)

Copy constructor is called when a new object is created from an existing object, as a copy of theexisting object. Assignment operator is called when an already initialized object is assigned anew value from another existing object. In the above example (1) calls copy constrictor and (2)calls assignment operator. See this for more details.

Although using the assignment operator is fairly straightforward, correctly imple

c Program Full

Documents

Transcript of c Program Full