Smu - Mca - Mc0066 Assign 1

August 2010
Master of Computer Application (MCA) – Semester 2

MC0066 – OOPS using C++ – 4 Credits (Book ID: B0681 & B0715)
Assignment Set – 1 (40 Marks)
Book ID: B0681
1. Describe the steps in compiling and executing a C++ program

with programmatic illustration.
Ans.
There are three steps in executing a c++ program: Compiling, Linking and
Running the program. The c++ programs have to be typed in a compiler.
All the programs discussed in the book will be compiled on turbo c++
compiler. The turbo c++ compiler comes with an editor to type and edit c+
+ program. After typing the program the file is saved with an extension
.cpp. This is known as source code. The source code has to be converted to
an object code which is understandable by the machine. This process is
known as compiling the program. You can compile your program by
selecting compile from compile menu or press Alt+f9. After compiling a file
with the same name as source code file but with extension .obj. is created.
Second step is linking the program which creates an executable file

.exe (filename same as source code) after linking the object code and the
library files (cs.lib) required for the program. In a simple program, linking
process may involve one object file and one library file. However in a
project, there may be several smaller programs. The object codes of these
programs and the library files are linked to create a single executable file.
Third and the last step is running the executable file where the statements
in the program will be executed one by one.
When you execute the program, the compiler displays the output of
the program and comes back to the program editor. To view the output and
wait for user to press any key to return to the editor, type getch() as the
last statement in the program. Getch() is an inbuilt predefined library
function which inputs a character from the user through standard input.
However you should include another header file named conio.h to use this
function. Conio.h contains the necessary declarations for using this
function. The include statement will be similar to iostream.h.
Compiling and Linking
During compilation, if there are any errors that will be listing by the
compiler. The errors may be any one of the following
August 2010
1. Syntax error
This error occurs due to mistake in writing the syntax of a c++

statement or wrong use of reserved words, improper variable names, using
variables without declaration etc. Examples are : missing semi colon or
paranthesis, type integer for int datatype etc. Appropriate error message
and the statement number will be displayed. You can see the statement
and make correction to the program file, save and recompile it.
2. Logical error
This error occurs due to the flaw in the logic. This will not be identified
by the compiler. However it can be traced using the debug tool in the
editor. First identify the variable which you suspect creating the error and
add them to watch list by selecting Debug ->Watches->Add watch. Write
the variable name in the watch expression. After adding all the variables
required to the watch list, go to the statement from where you want to
observe. If you are not sure, you can go to the first statement of the
program. Then select Debug ->Toggle Breakpoint (or press ctrl + f8). A red
line will appear on the statement. Then Run the program by selecting Ctrl +
f9 or Run option from run menu. The execution will halt at the statement
where you had added the breakpoint. The watch variables and their values
at that point of time will be displayed in the bottom in the watch window.
Press F8 to execute the next statement till you reach the end of the
program. In this way you can watch closely the values in the watch
variables after execution of each and every statement in the program. If
you want to exit before execution of the last statement press Ctrl + Break.
To remove the breakpoint in the program go to the statement where you
have added breakpoint select Debug ->Toggle Breakpoint (or press ctrl +
f8). Select Debug -> watch ->remove watches to remove the variables in
the watch list. This tool helps in knowing the values taken by the variable at
each and every step. You can compare the expected value with the actual
value to identify the error.
3. Linker error
This error occur when the files during linking are missing or mispelt
4. Runtime error
This error occurs if the programs encounters division by zero, accessing a

null pointer etc during execution of the program
August 2010
2. Describe the theory with programming examples the selection control statements in
C++.
Ans.
If statement
Syntax : if (expression or condition)
{ statement 1;
statement 2;
}
else
{ statement 3;
statement 4;
}
The expression or condition is any expression built using relational

operators which either yields true or false condition. If no relational
operators are used for comparison, then the expression will be evaluated
and zero is taken as false and non zero value is taken as true. If the
condition is true, statement1 and statement2 is executed otherwise
statement 3 and statement 4 is executed. Else part in the if statement is
optional. If there is no else part, then the next statement after the if
statement is exceuted, if the condition is false. If there is only one
statement to be executed in the if part or in the else part, braces can be
omitted.
Following example program implements the if statement.
// evenodd.cpp
# include <iostream.h>
# include <conio.h>
void main()
{
int num;
cout<<”Please enter a number”<<endl;
cin>>num;
if ((num%2) == 0)
cout<<num <<” is a even number”;
else
cout<<num <<” is a odd number”;
getch();
}
August 2010
The above program accepts a number from the user and divides it by
2 and if the remainder (remainder is obtained by modulus operator) is zero,
it displays the number is even, otherwise as odd. We make use of the
relational operator == to compare whether remainder is equal to zero or
not.
Nested If statement
If statement can be nested in another if statement to check multiple

conditions.
If (condition1)
{ if (condition 2)
{ statement1;
Statement2;
}
else if (condition3)
{statement3;
}
}
else statement4;
The flowchart of the above example is shown below
Multiple conditions can be checked using logical && operator(AND) and ||

operator (OR).
If ((condition1) && (condition2))

statement1;
else
statement2;
August 2010
In the above example statement1 will be executed if both the condition1

and condition2 are true and in all other cases statement2 will be executed.
If ((condition1 || (condition2))
statement1;
else
statement2;
In the above example statement1 will be executed if either condition1

or condition2 are true and even if both are true. Statement2 will be
executed if both the conditions are false. The following program
demonstrates the use of && operator and nested if statement.
//Large.cpp
# include <iostream.h>
void main()
{ int a,b,c;
cout<<”Please enter three numbers”;
cin>>a>>b>>c;
if ((a>b) && (b>c))
cout<<a<< “ is the largest number”;
else if ((b>a) && (b>c))
cout<<b<< “ is the largest number”;
else if ((c>a) && (c>b))
cout<<c<< “ is the largest number”;
}
The above program accepts three numbers from the user and
displays which is the largest number among the three.( assumption is that
all the numbers are unique, the program has to be modified if you would
like to allow same number twice)
Switch statement
Nested ifs can be confusing if the if statement is deeply nested. One

alternative to nested if is the switch statement which can be used to
increase clarity in case of checking the different values of the same variable
and execute statements accordingly.
Syntax :
Switch (variablename)
{ case value1: statement1;
break;
August 2010
case value2: statement2;

break;
case value3: statement3;
break;
default: statement4;
}
If the variable in the switch statement is equal to value1 then

statement1 is executed, if it is equal to value2 then statement2 is
executed, if it is value3 then statement3 is executed. If the variable value is
not in any of the cases listed then the default case statement or statement4
is executed. The default case specification is optional, however keeping it is
a good practice. It can also be used for displaying any error message. Each
case can have any number of statements. However every case should have
a break statement as the last statement. Break statement takes the control
out of the switch statement. The absence of the break statement can cause
execution of statements in the next case. No break is necessary for the last
case. In the above example, default case does not contain a break
statement.
The flowchart for the switch statement is shown below
The following program implements the switch statement
position.cpp
# include<iostream.h>
void main()
{ char pos;
int x=15, y=15;
August 2010
cout << “ you are currently located at” <<x<<” “<<y<<endl;

cout>>”please choose the letter to move l for left, r for right, u for up and d
for down” <<endl;
cin>>pos;
switch (pos)
{ case ‘l’: x–;
break;
case ‘r’: x++;
break;
case ‘u’: y++;
break;
case ‘d’: y–;
break;
default: cout<<”You selected a wrong option”;
}
cout<<“ you are now located at” <<x<<” “<<y;
}
The above program asks the user to enter l,r,u,d for allowing him to
move left,right,up and down respectively. The position is initialised to 15
and 15 which are x and y coordinates of his position. Depending upon the
what user has selected the the x and y co-ordinates are incremented or
decremented by one(x++ is same as x=x+1). If the user types a letter
other than l,r,u,d, he gets an error message. Since the switch variable is a
character, l,u,r,d and enclosed within single quote.
++ and — operator can be used as postfix or as prefix operator which

has no effect if used as an independent statement. However if it used as
part of an expression, the prefix operator will be operated and then the
expression will be evaluated whereas the postfix operated will be evaluated
later.
For example in the statement x= a+ (b++), a will be added to b and

then stored in x and then the value of b will be incremented. If the same
expression is written as x=a+(++b), the the b will be incremented and then
added to a and stored in x.
3. Given a RxC Matrix, A, i.e. R rows and C columns we define a Saddle-Point as

Saddle_Pt (A(i,j)) = A(i,j) is the minimum of Row i and the maximum of Col j.
e.g.
123
456
August 2010
789
-- 7 is Saddle_Pt. at position (3,1)
Write a program in C++ to check and print for saddle points in a matrix.
Ans.
#include<iostream.h>
#include<conio.h>
void main()
{
clrscr();
int a[3][3],i,j,k,sp,minr,pos,flag=1;
cout<<"Enter the contents of the array ";
for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
cin>>a[i][j];
}
cout<<"
The matrix representation of array is: ";
for(i=0;i<3;i++)
{
cout<<"
";
for(j=0;j<3;j++)
cout<<a[i][j]<<" ";
}
cout<<endl;
for(i=0;i<3;i++)
{
flag=1;
sp=a[i][0],pos=0;
for(j=1;j<3;j++)
{
if(a[i][j]<sp)
{ sp=a[i][j];
pos=j;
August 2010
}
}
for(k=0;k<3;k++)
{
if(a[k][pos]<sp)
{
flag=0;
break;
}
}
if(flag==1)
cout<<"The saddle point of row "<<i+1<<" is "<<sp<<endl;
}
getch();
}
4. Describe and Demonstrate the concept of Pass by Value and

Pass By Reference using appropriate programming examples of
your own.
Ans.
Pass by Value
Consider a pair of C++ functions defined in Program. The function One calls
the function Two. In general, every function call includes a (possibly empty)
list of arguments. The arguments specified in a function call are called
actual parameters . In this case, there is only one actual parameter y.
void Two(int x)
{
x=2;
cout << r << endl;
}
void One()
{
int y=1;
Two(y);
August 2010
cout << y << endl;

}
Program: Example of Pass-By-Value Parameter Passing
The method by which the parameter is passed to a function is determined
by the function definition. In this case, the function Two is defined as
accepting a single argument of type int called x. The arguments which
appear in a function definition are called formal parameters . If the type of a
formal parameter is not a reference , then the parameter passing method is
pass-by-value.
The semantics of pass-by-value work like this: The effect of the formal
parameter definition is to create a local variable of the specified type in the
given function. E.g., the function Two has a local variable of type int called
x. When the function is called, the values (r-values) of the actual
parameters are used to initialize the formal parameters before the body of
the function is executed.
Since the formal parameters give rise to local variables, if a new value is
assigned to a formal parameter, that value has no effect on the actual
parameters. Therefore, the output obtained produced by the function One
defined in Program is:
2
1
Pass by Reference
Consider the pair of C++ functions defined in Program . The only difference
between this code and the code given in Program is the definition of the
formal parameter of the function Two: In this case, the parameter x is
declared to be a reference to an int. In general, if the type of a formal
parameter is a reference, then the parameter passing method is pass-by-
reference .
void Two(int& x)
{
x=2;
cout << r << endl;
}
void One()
{
int y=1;
Two(y);
August 2010
cout << y << endl;

}
Program: Example of Pass-By-Reference Parameter Passing
A reference formal parameter is not a variable. When a function is called
that has a reference formal parameter, the effect of the call is to associate
the reference with the corresponding actual parameter. I.e., the reference
becomes an alternative name for the corresponding actual parameter.
Consequently, this means that the actual parameter passed by reference
must be variable.
A reference formal parameter can be used in the called function

everywhere that a variable can be used. In particular, if the reference
formal parameter is used where a r-value is required, it is the r-value of
actual parameter that is obtained. Similarly, if the reference parameter is
used where an l-value is required, it is the l-value of actual parameter that
is obtained. Therefore, the output obtained produced by the function one
defined in Program is:
2
2
Book ID: B0715
5. Describe the theory of Derivation and Inheritance.
Ans.
Derivation
Inheritance is implemented in C++ through the mechanism of derivation.

Derivation allows you to derive a class, called a derived class, from another
class, called a base class.
Derived class syntax
Derived class syntax

>>-derived_class--:--------------------------------------------->
.-,---------------------------------------------------------.--------
V |
>----+----------------------------+--qualified_class_specifier-+-><
+-virtual--+-----------+-----+
| +-public----+ |
| +-private---+ |
| '-protected-' |
August 2010
'-+-public----+--+---------+-'
+-private---+ '-virtual-'
'-protected-'
In the declaration of a derived class, you list the base classes of the derived
class. The derived class inherits its members from these base classes.
The qualified_class_specifier must be a class that has been previously

declared in a class declaration.
An access specifier is one of public, private, or protected.
The virtual keyword can be used to declare virtual base classes.
The following example shows the declaration of the derived class D and the
base classes V, B1, and B2. The class B1 is both a base class and a derived
class because it is derived from class V and is a base class for D:
class V { /* ... */ };
class B1 : virtual public V { /* ... */ };
class B2 { /* ... */ };
class D : public B1, private B2 { /* ... */ };
Classes that are declared but not defined are not allowed in base lists.
For example:
class X;
// error
class Y: public X { };
The compiler will not allow the declaration of class Y because X has not
been defined.
When you derive a class, the derived class inherits class members of the
base class. You can refer to inherited members (base class members) as if
they were members of the derived class. For example:
class Base {
public:
int a,b;
};
class Derived : public Base {
August 2010
public:
int c;
};
int main() {
Derived d;
d.a = 1; // Base::a
d.b = 2; // Base::b
d.c = 3; // Derived::c
}
The derived class can also add new class members and redefine existing
base class members. In the above example, the two inherited members, a
and b, of the derived class d, in addition to the derived class member c, are
assigned values. If you redefine base class members in the derived class,
you can still refer to the base class members by using the :: (scope
resolution) operator. For example:
#include <iostream>
using namespace std;
class Base {
public:
char* name;
void display() {
cout << name << endl;
}
};
class Derived: public Base {

public:
char* name;
void display() {
cout << name << ", " << Base::name << endl;
}
};
int main() {
Derived d;
d.name = "Derived Class";
d.Base::name = "Base Class";
// call Derived::display()
d.display();
August 2010
// call Base::display()
d.Base::display();
}
The following is the output of the above example:
Derived Class, Base Class

Base Class
You can manipulate a derived class object as if it were a base class object.
You can use a pointer or a reference to a derived class object in place of a
pointer or reference to its base class. For example, you can pass a pointer
or reference to a derived class object D to a function expecting a pointer or
reference to the base class of D. You do not need to use an explicit cast to
achieve this; a standard conversion is performed. You can implicitly convert
a pointer to a derived class to point to an accessible unambiguous base
class. You can also implicitly convert a reference to a derived class to a
reference to a base class.
The following example demonstrates a standard conversion from a pointer

to a derived class to a pointer to a base class:
#include <iostream>
class Base {
public:
char* name;
void display() {
cout << name << endl;
}
};
class Derived: public Base {

public:
char* name;
void display() {
cout << name << ", " << Base::name << endl;
}
};
int main() {
Derived d;
August 2010
d.name = "Derived Class";

d.Base::name = "Base Class";
Derived* dptr = &d;
// standard conversion from Derived* to Base*

Base* bptr = dptr;
// call Base::display()
bptr->display();
The following is the output of the above example:
Base Class
The statement Base* bptr = dptr converts a pointer of type Derived to a

pointer of type Base.
The reverse case is not allowed. You cannot implicitly convert a pointer or a
reference to a base class object to a pointer or reference to a derived class.
For example, the compiler will not allow the following code if the classes
Base and Class are defined as in the above example:
int main() {
Base b;
b.name = "Base class";
Derived* dptr = &b;

}
The compiler will not allow the statement Derived* dptr = &b because the
statement is trying to implicitly convert a pointer of type Base to a pointer
of type Derived.
If a member of a derived class and a member of a base class have the same
name, the base class member is hidden in the derived class. If a member of
a derived class has the same name as a base class, the base class name is
hidden in the derived class.
Inheritance
August 2010
Inheritance is a mechanism of reusing and extending existing classes

without modifying them, thus producing hierarchical relationships between
them.
Inheritance is almost like embedding an object into a class. Suppose that

you declare an object x of class A in the class definition of B. As a result,
class B will have access to all the public data members and member
functions of class A. However, in class B, you have to access the data
members and member functions of class A through object x. The following
example demonstrates this:
#include <iostream>
class A {
int data;
public:
void f(int arg) { data = arg; }
int g() { return data; }
};
class B {
public:
A x;
};
int main() {
B obj;
obj.x.f(20);
cout << obj.x.g() << endl;
// cout << obj.g() << endl;
}
In the main function, object obj accesses function A::f() through its data
member B::x with the statement obj.x.f(20). Object obj accesses A::g() in a
similar manner with the statement obj.x.g(). The compiler would not allow
the statement obj.g() because g() is a member function of class A, not class
B.
The inheritance mechanism lets you use a statement like obj.g() in the
above example. In order for that statement to be legal, g() must be a
member function of class B.
Inheritance lets you include the names and definitions of another class's
members as part of a new class. The class whose members you want to
August 2010
include in your new class is called a base class. Your new class is derived
from the base class. The new class contains a sub object of the type of the
base class. The following example is the same as the previous example
except it uses the inheritance mechanism to give class B access to the
members of class A:
#include <iostream>
class A {
int data;
public:
void f(int arg) { data = arg; }
int g() { return data; }
};
class B : public A { };
int main() {
B obj;
obj.f(20);
cout << obj.g() << endl;
}
Class A is a base class of class B. The names and definitions of the
members of class A are included in the definition of class B; class B inherits
the members of class A. Class B is derived from class A. Class B contains a
subobject of type A.
You can also add new data members and member functions to the derived
class. You can modify the implementation of existing member functions or
data by overriding base class member functions or data in the newly
derived class.
You may derive classes from other derived classes, thereby creating
another level of inheritance. The following example demonstrates this:
struct A { };
struct B : A { };
struct C : B { };
Class B is a derived class of A, but is also a base class of C. The number of

levels of inheritance is only limited by resources.
August 2010
Multiple inheritance allows you to create a derived class that inherits

properties from more than one base class. Because a derived class inherits
members from all its base classes, ambiguities can result. For example, if
two base classes have a member with the same name, the derived class
cannot implicitly differentiate between the two members. Note that, when
you are using multiple inheritance, the access to names of base classes
may be ambiguous.
A direct base class is a base class that appears directly as a base specifier
in the declaration of its derived class.
An indirect base class is a base class that does not appear directly in the
declaration of the derived class but is available to the derived class through
one of its base classes. For a given class, all base classes that are not direct
base classes are indirect base classes. The following example demonstrates
direct and indirect base classes:
class A {
public:
int x;
};
class B : public A {
public:
int y;
};
class C : public B { };
Class B is a direct base class of C. Class A is a direct base class of B. Class A

is an indirect base class of C. (Class C has x and y as its data members.)
Polymorphic functions are functions that can be applied to objects of more

than one type. In C++, polymorphic functions are implemented in two
ways:
•Overloaded functions are statically bound at compile time.

•C++ provides virtual functions. A virtual function is a function that can be
called for a number of different user-defined types that are related through
derivation. Virtual functions are bound dynamically at run time
6. Describe the Friend functions and friend classes with

programming examples.
Ans.
Friend function
August 2010
When a data is declared as private inside a class, then it is not accessible

from outside the class. A function that is not a member or an external class
will not be able to access the private data. A programmer may have a
situation where he or she would need to access private data from non-
member functions and external classes. For handling such cases, the
concept of Friend functions is a useful tool.
A friend function is used for accessing the non-public members of a class. A

class can allow non-member functions and other classes to access its own
private data, by making them friends. Thus, a friend function is an ordinary
function or a member of another class.
The friend function is written as any other normal function, except the
function declaration of these functions is preceded with the keyword friend.
The friend function must have the class to which it is declared as friend
passed to it in argument.
Some important points to note while using friend functions in C++:
The keyword friend is placed only in the function declaration of the friend
function and not in the function definition.
It is possible to declare a function as friend in any number of classes.
When a class is declared as a friend, the friend class has access to the
private data of the class that made this a friend.
A friend function, even though it is not a member function, would have the
rights to access the private members of the class.
It is possible to declare the friend function as either private or public.
The function can be invoked without the use of an object. The friend
function has its argument as objects, seen in example below.
#include
class exforsys
{
private:
int a,b;
public:
void test()
{
August 2010
a=100;
b=200;
}
friend int compute(exforsys e1)
//Friend Function Declaration with keyword friend and with the object of
class exforsys to which it is friend passed to it
};
int compute(exforsys e1)

{
//Friend Function Definition which has access to private data
return int(e1.a+e2.b)-5;
}
main()
{
exforsys e;
e.test();
cout<<"The result is:"< //Calling of Friend Function with object as
argument.
}
The output of the above program is
The result is:295
The function compute() is a non-member function of the class exforsys. In

order to make this function have access to the private data a and b of class
exforsys , it is created as a friend function for the class exforsys. As a first
step, the function compute() is declared as friend in the class exforsys as:
friend int compute (exforsys e1)
Friend Class
C++ provides the friend keyword to do just this. Inside a class, you can
indicate that other classes (or simply functions) will have direct access to
protected and private members of the class. When granting access to a
class, you must specify that the access is granted for a class using the class
keyword:
friend class aClass;
August 2010
Note that friend declarations can go in either the public, private, or

protected section of a class--it doesn't matter where they appear. In
particular, specifying a friend in the section marked protected doesn't
prevent the friend from also accessing private fields. Here is a more
concrete example of declaring a friend:
class Node
{
private:
int data;
int key;
// ...
friend class BinaryTree; // class BinaryTree can now access data directly
};
Now, Node does not need to provide any means of accessing the data
stored in the tree. The BinaryTree class that will use the data is the only
class that will ever need access to the data or key. (The BinaryTree class
needs to use the key to order the tree, and it will be the gateway through
which other classes can access data stored in any particular node.) Now in
the BinaryTree class, you can treat the key and data fields as though they
were public:
class BinaryTree
{
private:
Node *root;
int find(int key);

};
int BinaryTree::find(int key)
{
// check root for NULL...
if(root->key == key)
{
// no need to go through an accessor function
return root->data;
}
// perform rest of find
}
August 2010
7. Illustrate with suitable examples various file handling methods

in C++.
Ans.
Opening a File – Different Methods
So far we have seen just one way to open a file, either for reading,
either for writing. But it can be opened another way too. So far, you should
be aware of this method:
ifstream OpenFile(“cpp-home.txt”);
Well, this is not the only way. As mentioned before, the above code
creates an object from class ifstream, and passes the name of the file to be
opened to its constructor. But in fact, there are several overloaded
constructors, which can take more than one parameter. Also, there is
function open() that can do the same job. Here is an example of the above
code, but using the open() function:
ifstream OpenFile;
OpenFile.open(“cpp-home.txt”);
Other use of open() is for example if you open a file, then close it, and
using the same file handle open another file. This way, you will need the
open() function.
Consider the following code example:
#include <fstream.h>
void read(ifstream &T) { //pass the file stream to the function
//the method to read a file
char ch;
while(!T.eof()) {
T.get(ch);
cout << ch;
}
cout << endl << "——–" << endl;
}
void main() {
ifstream T("file1.txt");
read(T);
T.close();
August 2010
T.open("file2.txt");
read(T);
T.close();
}
So, as long as file1.txt and file2.txt exists and has some text into, you will
see it.
ifstream OpenFile(char *filename, int open_mode);
You should know that filename is the name of the file (a string). What
is new here is the open_mode. The value of open_mode defines how to a
file can be opened. Here is a table of the open modes:
ios::in Open file to read

ios::out Open file to write
ios::app All the date you write, is put at the end of the file. It calls
ios::out
ios::ate All the date you write, is put at the end of the file. It does not
call ios::out
ios::trunc Deletes all previous content in the file. (empties the file)
ios::nocreat If the file does not exists, opening it with the open() function
e gets impossible.
ios::norepla If the file exists, trying to open it with the open() function,
ce returns an error.
ios::binary Opens the file in binary mode.
All these values are int constants from an enumerated type. But for
making your life easier, you can use them as you see them in the table.
Here is an example on how to use the open modes:
void main() {
ofstream SaveFile("file1.txt", ios::ate);
SaveFile << "That’s new!n";
SaveFile.close();
}
As you see in the table, using ios::ate will write at the end of the file.
If it wasn’t used, the file would have been overwritten. So, if file1.txt has
this text:
August 2010
Hi! This is test from www.cpp-home.com!
Running the above code, will add “That’s new!” to it, so it will look this way:
Hi! This is test from www.cpp-home.com!That’s new!
If you want to set more than one open mode, just use the OR operator (|).
This way:
ios::ate | ios::binary
Using different open modes helps make file handling an easy job. Having
the liberty to choose a combination of these, in a sane way, comes in very

handy in using streams effectively, and to the requirements of the project.
Moving on to something more intriguing and important; we can create a file

stream handle, which you can use to read/write file, in the same time. Here
is how it works:
fstream File(“cpp-home.txt”, ios::in | ios::out);
In fact, that is only the declaration. The code line above creates a file
stream handle, named File. As you know, this is an object from class
fstream. When using fstream, you should specify ios::in and ios::out as open
modes. This way, you can read from the file, and write in it, in the same
time, without creating new file handles. Well, of course, you can only read
or write. Here is the code example:
void main() {
fstream File("test.txt", ios::in | ios::out);
File << "Hi!"; //put “Hi!” in the file
static char str[10]; //when using static, the array is automatically
//initialized, and very cell NULLed
File.seekg(ios::beg); //get back to the beginning of the file
//this function is explained a bit later
File >> str;
cout << str << endl;
File.close();
}
Let us now understand the above program:

August 2010
fstream File(“test.txt”, ios::in | ios::out);
This line, creates an object from class fstream. At the time of execution, the
program opens the file test.txt in read/write mode. This means, that you
can read from the file, and put data into it, at the same time.
File << “Hi!”;
I am sure the reader is aware of this and hence the explanation for this
statement is redundant.
static char str[10];
This makes a char array with 10 cells. The word static initializes the array
when at the time of creation.
File.seekg(ios::beg);
To understand this statement, let us go back and recollect some basics. We

have seen this before:
while(!OpenFile.eof()) {
OpenFile.get(ch);
cout << ch;
}
This is a while loop, that will loop until you reach the end of the file.
But how does the loop know if the end of the file is reached? The answer is;
when you read the file, there is something like an inside-pointer (current
reading/writing position) that shows where you are up to, with the reading
(and writing, too). Every time you call OpenFile.get(ch) it returns the
current character to the ch variable, and moves the inside-pointer one
character after that, so that the next time this function is called, it will
return the next character. And this repeats, until you reach the end of the
file.
Going back to the code line; the function seekg() will put the inside-pointer
to a specific place (specified by you). One can use:
· ios::beg – to put it in the beginning of the file
· ios::end – to put it at the end of the file

August 2010
Or you can also set the number of characters to go back or after. For
example, if you want to go 5 characters back, you should write:
File.seekg(-5);
If you want to go 40 characters after, just write:
File.seekg(40);
It is imperative to mention that the seekg() function is overloaded, and it
can take two parameters, too. The other version is this one:
File.seekg(-5, ios::end);
In this example, you will be able to read the last 4 characters of the text,
because:
· You go to the end (ios::end)
· You go 5 characters before the end (-5)
Why you will read 4 but not 5 characters? One character is lost, because
the last thing in the file is neither a character nor white space. It is just
position (i.e., end of file).
Why this function was used the program above. After putting “Hi!” in the
file, the inside-pointer was set after it, i.e., at the end of the file. And as we
want to read the file, there is nothing that can be read at the end. Hence,
we have to put the inside-pointer at the beginning. And that is exactly what
this function does.
File >> str;
I believe this line reminds us of cin >>. In fact, it has much to do with it.
This line reads one word from the file, and puts it into the specified array.
For example, if the file has this text:
Hi! Do you know me?
Using File >> str, will put just “Hi!” to the str array. And, as what we put in
the file was “Hi!” we don’t need to do a while loop, that takes more time to
code. That’s why this technique was used. By the way, in the while loop for
reading, that was used so far, the program reads the file, char by char. But
you can read it word by word, this way:
August 2010
char str[30]; //the word can’t be more than 30 characters long

while(!OpenFile.eof()){
OpenFile >> str;
cout << str;
}
You can also read it line by line, this way:
char line[100]; //a whole line will be stored here
while(!OpenFile.eof()) {
OpenFile.getline(line,100); //where 100 is the size of the array
cout << line << endl;
}
8. Explain the concept of class templates in C++ with some real

time programming examples.
Ans.
A class template definition looks like a regular class definition, except it is
prefixed by the keyword template. For example, here is the definition of a
class template for a Stack.
template <class T>
class Stack {
public:
Stack(int = 10);
~Stack() { delete [] stackPtr ; }
int push(const T&);
int pop(T&);
int isEmpty()const { return top == -1; }
int isFull() const { return top == size – 1; }
private:
int size; // number of elements on Stack.
int top;
T* stackPtr;
};
T is a type parameter and it can be any type. For example,

Stack<Token>, where Token is a user defined class. T does not have to be
a class type as implied by the keyword class. For example, Stack<int> and
Stack<Message*> are valid instantiations, even though int and Message*
are not "classes".
Implementing Class Template Member Functions

August 2010
Implementing template member functions is somewhat different

compared to the regular class member functions. The declarations and
definitions of the class template member functions should all be in the
same header file. The declarations and definitions need to be in the same
header file.
Consider the following:
//B.H //B.CPP //MAIN.CPP

template <class t> #include "B.H" #include "B.H"
class b { template <class void main() {
public: t> b<int> bi;
b(); b<t>::b() { b <float> bf;
~b(); } }
}; template <class
t>
b<t>::~b() {
}
When compiling B.cpp, the compiler has both the declarations and
the definitions available. At this point the compiler does not need to
generate any definitions for template classes, since there are no
instantiations. When the compiler compiles main.cpp, there are two
instantiations: template class B<int> and B<float>. At this point the
compiler has the declarations but no definitions.
While implementing class template member functions, the definitions

are prefixed by the keyword template. Here is the complete implementation
of class template Stack:
//stack.h
#pragma once
template <class T>
class Stack {
public:
Stack(int = 10);
~Stack() { delete [] stackPtr; }
int push(const T&);
int pop(T&); // pop an element off the stack
int isEmpty()const { return top == -1; }
int isFull() const { return top == size – 1; }
private:
int size; // Number of elements on Stack
August 2010
int top;
T* stackPtr;
};
//constructor with the default size 10
template <class T>
Stack<T>::Stack(int s) {
size = s > 0 && s < 1000 ? s : 10;
top = -1; // initialize stack
stackPtr = new T[size];
}
// push an element onto the Stack
template <class T>
int Stack<T>::push(const T& item) {
if (!isFull())
{
stackPtr[++top] = item;
return 1; // push successful
}
return 0; // push unsuccessful
}
// pop an element off the Stack
template <class T>
int Stack<T>::pop(T& popValue) {
if (!isEmpty())
{
popValue = stackPtr[top--];
return 1; // pop successful
}
return 0; // pop unsuccessful
}
Using a class template
Using a class template is easy. Create the required classes by

plugging in the actual type for the type parameters. This process is
commonly known as "Instantiating a class". Here is a sample driver class
that uses the Stack class template.
#include <iostream>
#include "stack.h"
void main() {
typedef Stack<float> FloatStack;
typedef Stack<int> IntStack;
August 2010
FloatStack fs(5);
float f = 1.1;
cout << "Pushing elements onto fs" << endl;
while (fs.push(f))
{
cout << f << ‘ ‘;
f += 1.1;
}
cout << endl << "Stack Full." << endl
<< endl << "Popping elements from fs" << endl;
while (fs.pop(f))
cout << f << ‘ ‘;
cout << endl << "Stack Empty" << endl;
cout << endl;
IntStack is;
int i = 1.1;
cout << "Pushing elements onto is" << endl;
while (is.push(i))
{
cout << i << ‘ ‘;
i += 1;
}
cout << endl << "Stack Full" << endl
<< endl << "Popping elements from is" << endl;
while (is.pop(i))
cout << i << ‘ ‘;
cout << endl << "Stack Empty" << endl;
}
Output:
Pushing elements onto fs

1.1 2.2 3.3 4.4 5.5
Stack Full.
Popping elements from fs
5.5 4.4 3.3 2.2 1.1
Stack Empty
Pushing elements onto is
1 2 3 4 5 6 7 8 9 10
Stack Full
Popping elements from is
10 9 8 7 6 5 4 3 2 1
Stack Empty
August 2010
In the above example we defined a class template Stack. In the driver

program we instantiated a Stack of float (FloatStack) and a Stack of
int(IntStack). Once the template classes are instantiated you can instantiate
objects of that type (for example, fs and is.)
There are two advantages:
· typedef’s are very useful when "templates of templates" come into usage.
For example, when instantiating an STL vector of int’s, you could use:
typedef vector<int, allocator<int> > INTVECTOR;
· If the template definition changes, simply change the typedef definition.

For example, currently the definition of template class vector requires a
second parameter.
typedef vector<int, allocator<int> > INTVECTOR;

INTVECTOR vi1;
In a future version, the second parameter may not be required, for
example,
typedef vector<int> INTVECTOR;
INTVECTOR vi1;

Smu - Mca - Mc0066 Assign 1

Hochgeladen von

Dokumentinformationen

Originalbeschreibung:

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Smu - Mca - Mc0066 Assign 1

Hochgeladen von

Copyright:

Verfügbare Formate

August 2010

Master of Computer Application (MCA) – Semester 2

Book ID: B0681

1. Describe the steps in compiling and executing a C++ program

Second step is linking the program which creates an executable file

Compiling and Linking

This error occurs due to mistake in writing the syntax of a c++

This error occurs if the programs encounters division by zero, accessing a

The expression or condition is any expression built using relational

Following example program implements the if statement.

If statement can be nested in another if statement to check multiple

The flowchart of the above example is shown below

Multiple conditions can be checked using logical && operator(AND) and ||

If ((condition1) && (condition2))

In the above example statement1 will be executed if both the condition1

In the above example statement1 will be executed if either condition1

Nested ifs can be confusing if the if statement is deeply nested. One

case value2: statement2;

If the variable in the switch statement is equal to value1 then

The flowchart for the switch statement is shown below

The following program implements the switch statement

cout << “ you are currently located at” <<x<<” “<<y<<endl;

++ and — operator can be used as postfix or as prefix operator which

For example in the statement x= a+ (b++), a will be added to b and

3. Given a RxC Matrix, A, i.e. R rows and C columns we define a Saddle-Point as

4. Describe and Demonstrate the concept of Pass by Value and

cout << y << endl;

cout << y << endl;

A reference formal parameter can be used in the called function

Book ID: B0715

5. Describe the theory of Derivation and Inheritance.

Inheritance is implemented in C++ through the mechanism of derivation.

Derived class syntax

Derived class syntax

The qualified_class_specifier must be a class that has been previously

An access specifier is one of public, private, or protected.

The virtual keyword can be used to declare virtual base classes.

class D : public B1, private B2 { /* ... */ };

class Derived: public Base {

The following is the output of the above example:

Derived Class, Base Class

The following example demonstrates a standard conversion from a pointer

class Derived: public Base {

d.name = "Derived Class";

Derived* dptr = &d;

// standard conversion from Derived* to Base*

The following is the output of the above example:

The statement Base* bptr = dptr converts a pointer of type Derived to a

Derived* dptr = &b;

Inheritance is a mechanism of reusing and extending existing classes

Inheritance is almost like embedding an object into a class. Suppose that

Class B is a derived class of A, but is also a base class of C. The number of

Multiple inheritance allows you to create a derived class that inherits

Class B is a direct base class of C. Class A is a direct base class of B. Class A

Polymorphic functions are functions that can be applied to objects of more

•Overloaded functions are statically bound at compile time.

6. Describe the Friend functions and friend classes with

When a data is declared as private inside a class, then it is not accessible

A friend function is used for accessing the non-public members of a class. A

Some important points to note while using friend functions in C++:

It is possible to declare a function as friend in any number of classes.

It is possible to declare the friend function as either private or public.

int compute(exforsys e1)