C++ Interview Questions and Answers - FAQ

Is it possible to have Virtual Constructor? If yes, how? If not, Why not possible?

2009-09-07T02:57:00.000-07:00

A: There is nothing like Virtual Constructor. The Constructor can’t be virtual as the constructor is a code which is responsible for creating an instance of a class and it can’t be delegated to any other object by virtual keyword means.

What is a friend class/function? Why would you need it?

2009-09-01T20:24:00.000-07:00

Shortly, friend class or function is a class or a function that declared friend of an other class. The idea behind friend class is to provide the access to the private and protected members or member functions of the friend class. There is a lot of controversial opinions on this topic and you should not usually use friends as it is a hole in your design. One of the examples where it's used is a momento design pattern.

In C++ I can declare a reference to a pointer. Can I not also declare a pointer to a reference? Why or How?

2009-08-31T20:24:00.000-07:00

No, you cannot. It is explicitly stated in C++ spec that pointers to references are prohibited.

What is a reference?

2009-08-30T20:24:00.000-07:00

A reference is a quantity that holds the address of an object but behaves syntactically like that object. A reference cannot exist without object and must be initialized.

In C++, how do I force derived classes to implement a virtual method from the base class?"

2009-08-29T20:24:00.000-07:00

Use pure virtual function.

What is a pure virtual method (function)? What is the syntax for a pure virtual method? What is an abstract class?

2009-08-28T20:23:00.000-07:00

Pure virtual function is a function that declared with "=0;" specifier. Pure virtual function does not have body and must be overridden in the derived class. The syntax for pure virtual function is virtual void foo() = 0; Abstract class is a class with at least one pure virtual function.

What is a singleton? Write a simple implementation of a singleton.

2009-08-27T20:23:00.000-07:00

Singleton is a class that can have only one instance. For singleton example, see Singleton pattern in "Design Patterns" of E.Gamma, etc.

Write a simple referenced-counted smart pointer class.

2009-08-26T20:22:00.000-07:00

This question, in fact, is quite simple. I will not give you an example here, but look at auto_ptr (STL) and CComPtr (ATL) in order to provide your own implementation of reference-counted smart pointer class. Check also http://web.ftech.net/~honeyg/articles/smartp.htm

When and why should you avoid a multiple inheritance. What are the good examples of MI usage?

2009-08-25T20:22:00.000-07:00

You should avoid so called diamond structure where a class derives from several base classes which, in turn, have common base class. Good example of MI is an ATL which is based on the idea of MI.

What books did you read recently?

2009-08-24T20:22:00.000-07:00

While this question seems to be a silly one, it is easiest to be prepared to. I think it worth to mention Meyers, Gamma, Coplien, Stroustrup, Schildt etc.

What is the virtual destructor. When and why do you need it? (Be surprised if you are not asked this question!)

2009-08-23T20:21:00.000-07:00

Destructor implemented by declaring a base class's destructor with the keyword virtual. A virtual destructor ensures that, when delete is applied to a base class pointer or reference, it calls the destructor implemented in the derived class, if an implementation exists.

What is the namespace?

2009-08-22T20:20:00.000-07:00

A namespace allows you to resolve conflict of the global identifiers when you use, for example, two different libraries of different vendors, which use the same names. Of course, if the vendors of libraries also use the same name for the namespace, you cannot resolve the name conflict with namespace feature of C++ !

What is the difference between struct and class?

2009-08-21T20:15:00.000-07:00

There are few differences:
All members of struct are public.
Default inheritance for struct is public, where as for class the default inheritance is private.

Describe the role of envelope and letter classes.

2009-08-19T20:12:00.000-07:00

I was actually asked this question at one of my interviews. I guess the single purpose of this question is to paralyze the interviewee. In my case the interviewer has achieved the goal and I am glad I did not pass an interview to that company. The interviewer actually tried to fetch a basic overview of C++ paradigms and design patterns (this envelope/letter paradigm is described in the book of Coplien from 1995) While I do not question the importance of design patterns, all I was talking to agreed that in this form the question demonstrate inability of the interviewer to conduct the interview. You may safely ignore this question if you asked :)

What is the difference between "overloading" and "overriding"?

2009-08-18T20:12:00.000-07:00

Overloading is the practice of supplying more than one definition for a given function name in the same scope. The compiler is left to pick the appropriate version of the function or operator based on the arguments with which it is called. Overriding refers to the virtual functions, i.e. functions that ensure that the correct function is called for an object, regardless of the expression used to make the function call. For example, if the same function with virtual attribute is declared in base and derived class, the function from the derived class is invoked for objects of the derived class, even if it is called using a pointer or reference to the base class.

Why do you need a virtual base class?

2009-08-17T20:08:00.000-07:00

Virtual base classes offer a way to save space and avoid ambiguities in class hierarchies that use multiple inheritance. Each nonvirtual object contains a copy of the data members defined in the base class. When a base class is specified as a virtual base, it can act as an indirect base more than once without duplication of its data members. A single copy of its data members is shared by all the base classes that use it as a virtual base.

What is polymorphism?

2009-08-16T20:10:00.000-07:00

An object-oriented programming term. The ability to have methods with the same name, but different content, for related classes. The procedure to use is determined at run time by the class of the object. For example, related objects might both have Draw methods. A procedure, passed such an object as a parameter, can call the Draw method without needing to know what type of object the parameter is.

What is the purpose of separating a class implementation from its interface

2009-08-15T20:10:00.000-07:00

Encapsulation.

What is encapsulation?

2009-08-15T20:04:00.000-07:00

An object-oriented programming term for the ability to contain and hide information about an object, such as internal data structures and code. Encapsulation isolates the internal complexity of an object's operation from the rest of the application.

What is "inline" function?

2009-08-14T20:11:00.000-07:00

inline keyword before name of the function allows the compiler to insert a copy of the function body into each place the function is called. Therefore, the size of the code is increasing, but speed of execution is also increasing. You should mention that there are circumstances (e.g. recursive functions) when compiler is allowed to ignore inline keyword.

What is inheritance?

2009-08-14T20:08:00.000-07:00

An object-oriented programming term. The ability of a subclass to take on the characteristics of the class it's based on. If the characteristics of the parent class change, the subclass on which it is based inherits those characteristics.

String Manipulation

2008-12-12T21:11:00.001-08:00

You have been hired as a contract programmer by the Smithfield Natural Gas company.
Your first job is to write a program that prints a form letter to customers with an overdue
account. The letter should have the form shown in Figure . When the letter is printed by
your program, however, the fields shown in brackets will be replaced by actual values.

Figure
Dear

:

Our records show that your account has a balance of $ and
a past-due amount of $. Your last payment was on .
Since we haven't heard from you in some time, would you please take
a moment to send us a check for the past-due amount? We value your
business and look forward to serving you in the future.
Sincerely,

The Management P.S. If you've already sent your payment, ignore this reminder.
Inside the letter, the fields listed in Table are shown in brackets.

Table
Field Description
Salutation (either Mr. or Ms.)
Salutation
The customer’s last name
Last-Name
The customer’s total account balance
Balance
The amount the account is past due
Past-Due
The date the customer last made a payment
Date

String Manipulation
Before the letter is printed, your program should ask the user to enter values for the fields
listed in Table . The values should then be inserted into the form letter as it is being
printed. The program should perform word-wrap, which means the sentences should be
adjusted so no word is split between two lines. Additionally, the letter should have -
character left and right margins.

Variables
Table lists the major variables needed.
Table
Variable Description
Eight constant global character arrays that hold portions of the form
part...part
letter A character array to hold the salutation
salutation
A character array to hold the customer’s last name
lastName
A character array to hold the date of the last payment
lastPayment
A character array to hold the text representation of the account
balance
balance
A character array to hold the text representation of the past due
pastDue
amount
A character to hold the user’s Y or N response when asked if they wish
again
to print another letter
An integer that holds the printing position. Each time a character is
position
printed, this variable is incremented. It is used to determine when the
end of the line is near
Global Variables
The program uses eight constant global character arrays to hold the sections of the form
letter that are always the same. The arrays, named
through
, are defined and
Part
Part
initialized as follows:
const char part[] = "Dear ";
const char part[] = "Our records show that your account has a"
" balance of $";
const char part[] = " and a past due amount of $";
const char part[] = "Your last payment was on ";
const char part[] = "Since we haven't heard from you in some"
" time, would you please take a moment to send"
" us a check for the past due amount? We value"
" your business and look forward to serving you"
" in the future.\n\n";
const char part[] = "Sincerely,\n";
const char part[] = "The Management\n\n";
const char part[] = "P.S. If you've already sent your payment, ignore"
" this reminder.";

String Manipulation
NOTE:
Notice that some of the arrays are initialized with what appears to be more than
one string. For instance, look at the initialization of
:
part
const char part[] = "Our records show that your account has a"
" balance of $";
The two strings are actually concatenated into one string. This allows the pogrammer to
easily span multiple lines when initializing character arrays with long strings. The same
technique is used with
and
.
part
part
Modules
The program will consist of the functions listed in Table .
Table
Function Description
The program’s
function. Calls the
and
main
main
getInfo
printLetter
functions.
Calls the
function to get the salutation. Then asks the user to enter
getInfo
getSal
the customer’s last name, account balance, past-due amount, and date of
last payment.
Prints a menu allowing the user to select either Mr. or Ms. as the
getSal
salutation.
Controls the printing of the form letter once the fields have been input by
printLetter
the user. Calls the
function.
printLine
Prints a line of text starting at the current printing position. This function
printLine
performs word-wrap when near the end of the line. It keeps the
position
variable updated as well.
Function
main
Function
contains the array definitions for the salutation, last name, date of last pay-
main
ment, account balance, and past due amount. A
loop calls the
and
do-while
getInfo
functions. The loop repeats as long as the user wishes to print form letters.
printLetter
Here is the pseudocode:
Do
Call getInfo to get the salutation, last name, balance, past-due
amount, and date of last payment from the user.
Call printLetter to print the form letter.
Ask the user if another letter is to be printed.
While the user wants to print another letter.

String Manipulation
Here is the function’s actual C++ code:
int main()
{
char salutation[]; // To hold the salutation
char lastName[]; // Customer's last name
char lastPayment[]; // Date of last payment
char balance[]; // Account balance
char pastDue[]; // Amount past due
char again; // To hold Y or N
do
{
// Call getInfo to get input from the user
getInfo(salutation, lastName, balance, pastDue,
lastPayment);
cout << "\n\n";
// Now print the form letter
printLetter(salutation, lastName, balance, pastDue,
lastPayment);
cout << "\n\nDo another letter? (Y/N) ";
cin >> again;
} while (toupper(again) == 'Y');
return ;
}
Notice that pointers to
,
,
,
, and
salutation
lastName
balance
pastDue
lastPayment
are passed to
and
. When
returns, these fields will have
getInfo
printLetter
getInfo
the values provided by the user stored in them.
will retrieve the values and
printLetter
insert them in the form letter.
The
getInfo
Function
This function first calls the
function (to get the salutation), and then asks the user
getSal
to enter the customer’s last name, account balance, past due amount, and the date of the
last payment. These values are then stored in the arrays whose addresses are passed into
the function as arguments. Here is the pseudocode:
Call getSal.
Ask the user to enter the customer’s last name.
Convert the first character of the last name to upper case.
Ask the user to enter the customer’s account balance.
Ask the user to enter the account’s past due amount.
Ask the user to enter the date of the last payment.
Notice that after the user enters the customer’s last name, the function automatically con-
verts its first character to upper case. This is in case the user entered the name in all lower
case. Here is the function’s C++ code:
void getInfo(char *sal, char *lname, char *bal, char *due,
char *lastPay)
{
getSal(sal);
cout << "Last name: ";
cin >> lname;

String Manipulation
lname[] = toupper(lname[]);
cout << "Account balance: ";
cin >> bal;
cout << "Past due amount: ";
cin >> due;
cout << "Date of last payment(MM/DD/YYYY): ";
cin >> lastPay;
}
The
getSal
Function
This function displays a menu allowing the user to select a salutation from either Mr. or
Ms. The choice is then stored in the array whose address is passed into the function as an
argument. Here is the pseudocode:
Do
Display menu with choice being Mr. and choice being Ms.
Ask user to select a salutation.
While the user does not select or from the menu.
If the user selected
The salutation is Mr.
else
The salutation is Ms.
End If.
Here is the function’s C++ code:
void getSal(char *sal)
{
int choice;
do
{
cout << "Salutation:\n";
cout << "\t) Mr.\n";
cout << "\t) Ms.\n";
cout << "Select one: ";
cin >> choice;
} while (choice != && choice != );
if (choice == )
strcpy(sal, "Mr.");
else
strcpy(sal, "Ms.");
}
The
printLetter
Function
Once the user has entered values for all the fields, this function controls the printing of the
letter. It has one local variable,
, which is an integer. This variable keeps track of
position
the number of characters printed on the current line. This is crucial information for the
function, which performs word-wrap. Below is the function’s pseudocode. (It
printLine
might help you to refer to the contents of the global arrays
through
as you
Part
Part
read the code.)

String Manipulation
// First print the salutation part of the letter.
Set the position variable to (for printLine).
Call printLine to print the part array.
Print the salutation, followed by a space, followed by the
customer’s last name, followed by a colon.
// Next print the body of the letter.
Set the position variable to zero.
Call printLine to print the part array.
Print the customer’s balance.
Adjust the position variable.
Call printLine to print the part array.
Print the past-due amount.
Adjust the position variable.
Call printLine to print the part array.
Print the date of the last payment.
Adjust the position variable.
Call printLine to print the part array.
// Next print the letter’s closing.
Set the position variable to zero (to start a new line.)
Call printLine to print the part array.
Set the position variable to zero (to start a new line).
Call printLine to print the part array.
// Last, print the PS reminder.
Set the position variable to zero (to start a new line).
Call printLine to print the part array.
The
function updates the
variable. When
prints one
printLine
position
PrintLetter
of the fields, such as balance, it must adjust the position variable. This is so the
function will accurately detect the end of each line. Notice that every time a
printLine
new line is to be started,
is reset to zero. Here is the C++ code for the function:
position
void printLetter(char *sal, char *lname, char *bal, char *due,
char *lastPay)
{
int position;
// Print the salutation part of the letter
position = ; // Start a new line
printLine(part, position);
cout << sal << " " << lname << ":" << endl << endl;
// Print the body of the letter
position = ; // Start a new line.
printLine(part, position);
cout << bal; // Print account balance.
// Add length of balance to position.
position += strlen(bal);
printLine(part, position);
cout << due << ". "; // Print past due amount
position += strlen(due)+ ;
// Add length of due and the period and space at the
// end of the sentence to position.
printLine(part, position);
cout << lastPay << ". "; // Print date of last payment.

String Manipulation
// Now Add length of lastPay and the period and space at the
// end of the sentence to position.
position += strlen(lastPay) + ;
printLine(part, position);
// Print the closing
position = ; // Start a new line
printLine(part, position);
position = ; // Start a new line
printLine(part, position);
// Print the PS reminder
position = ; // Start a new line
printLine(part, position);
}
The printLine Function
This function prints each individual line of the letter. It takes two arguments: the address
of the string that is to be printed on the line, and the variable used to store the number of
characters printed (the
variable). The number of characters printed on the line
position
is important because the program must perform word-wrap. This happens when the word
being printed at the end of a line will not entirely fit. Instead of printing part of the word
on one line and then continuing it on the next line, the program is to start the word on the
next line. Here is the function’s pseudocode:
If the line is at or past the right margin
Start a new line.
End If.
While not at the end of the string
If or more characters have been printed AND the next
character is a space
Perform word-wrap.
End If.
If at the beginning of a new line
Print the left margin ( spaces).
Add to the number of characters printed.
End If.
Print the next character.
Add one to the number of characters printed.
End While.
The first
statement simply checks to see if the current printing position is at or beyond
if
the right margin. Because the letter has ten-character margins, any position beyond the
th character is in the right margin.
Inside the
loop another
statement checks to see if or more characters have
while
if
been printed. This is the part that controls word-wrap. The function begins watching for a
space separating words at the th character. If a break between two words appears any-
where after the th character, a new line is started. The next
statement checks to see
if
a new line has begun. If so, it prints the spaces that make the left margin. After all
if
this has taken place, the next character is printed and the character count is incremented.

String Manipulation
Here is the C++ code for the function:
void printLine(const char *line, int &startCount)
{
int charCount = ;
if (startCount >= ) // If the line is already at
{ // or past the right margin...
cout << "\n"; // Start a new line.
startCount = ; // Reset startCount.
}
// The following while loop cycles through the string
// printing it one character at a time. It watches for
// spaces after the th position so word-wrap may be
// performed.
while (line[charCount] != '\')
{
if (startCount >= && line[charCount] == ' ')
{
cout << " \n"; // Print right margin.
charCount++; // Skip over the space
startCount = ;
}
if (startCount == )
{
cout << " "; // Print left margin.
startCount = ;
}
cout.put(line[charCount]); // Print the character.
charCount++; // Update subscript.
startCount++; // Update position counter.
}
}
NOTE:
The
parameter is a reference to the
variable in the
startCount
position
function.
printLetter
The Entire Program
Program - shows the entire program’s source code.

String Manipulation
Program -

// This program prints a simple form letter reminding a customer

// of an overdue account balance.

#include

#include

#include

using namespace std;

// Function Prototypes

void printLetter(char *, char *, char *, char *, char *);

void getInfo(char *, char *, char *, char *, char *);

void getSal(char *);

void printline(const char *, int&);

// Strings that make up the form letter

const char part[] = "Dear ";

const char part[] = "Our records show that your account has a"

" balance of $";

const char part[] = " and a past due amount of $";

const char part[] = "Your last payment was on ";

const char part[] = "Since we haven't heard from you in some"

" time, would you please take a moment to send"

" us a check for the past due amount? We value"

" your business and look forward to serving you"

" in the future.\n\n";

const char part[] = "Sincerely,\n";

const char part[] = "The Management\n\n";

const char part[] = "P.S. If you've already sent your payment, ignore"

" this reminder.";

int main()

{

char salutation[]; // To hold the salutation

char lastName[]; // Customer's last name

char lastPayment[]; // Date of last payment

char balance[]; // Account balance

char pastDue[]; // Amount past due

char again; // To hold Y or N

do

{

// Call getInfo to get input from the user

getInfo(salutation, lastName, balance, pastDue,

lastPayment);

cout << "\n\n";

// Now print the form letter

printLetter(salutation, lastName, balance, pastDue,

lastPayment);

cout << "\n\nDo another letter? (Y/N) ";

cin >> again;

} while (toupper(again) == 'Y');

return ;

}

(program continues)

String Manipulation
Program -
(continued)

//*****************************************************************

// Definition of function getInfo. *

// This function allows the user to enter the following items: *

// salutation, last name, account balance, past due amount, and *

// date of last payment. The function arguments are pointers to *

// strings where the input will be stored. *

//*****************************************************************

void getInfo(char *sal, char *lname, char *bal, char *due,

char *lastPay)

{

getSal(sal);

cout << "Last Name: ";

cin >> lname;

lname[] = toupper(lname[]);

cout << "Account balance: ";

cin >> bal;

cout << "Past due Amount: ";

cin >> due;

cout << "Date of last payment (MM/DD/YYYY): ";

cin >> lastPay;

}

//****************************************************************

// Definition of function getSal. *

// This function gives the user a menu from which to pick a *

// suitable title for the letter's addressee. The choices are *

// Mr. and Ms. The choice will be copied to the address pointed *

// to by sal. *

//****************************************************************

void getSal(char *sal)

{

int choice;

do

{

cout << "salutation:\n";

cout << "\t) Mr.\n";

cout << "\t) Ms.\n";

cout << "Select one: ";

cin >> choice;

} while (choice != && choice != );

if (choice == )

strcpy(sal, "Mr.");

else

strcpy(sal, "Ms.");

}

(program continues)

String Manipulation
Program -
(continued)

//*************************************************************

// Definition of function printLetter. *

// This function prints the form letter. The parameters are *

// pointers to the fields that contain user input. *

//*************************************************************

void printLetter(char *sal, char *lname, char *bal, char *due,

char *lastPay)

{

int position;

// Print the salutation part of the letter

position = ; // Start a new line.

printline(part, position);

cout << sal << " " << lname << ":" << endl << endl;

// Print the body of the letter

position = ; // Start a new line.

printline(part, position);

cout << bal; // Print account balance.

// Add length of balance to position.

position += strlen(bal);

printline(part, position);

cout << due << ". "; // Print past due amount

position += strlen(due)+ ;

// Add length of due and the period and space at the

// end of the sentence to position.

printline(part, position);

cout << lastPay << ". "; // Print date of last payment.

// Now Add length of lastPay and the period and space at the

// end of the sentence to position.

position += strlen(lastPay) + ;

printline(part, position);

// Print the closing.

position = ; // Start a new line.

printline(part, position);

position = ; // Start a new line.

printline(part, position);

// Print the PS reminder.

position = ; // Start a new line.

printline(part, position);

}

(program continues)

String Manipulation
Program -
(continued)

//*******************************************************************

// Definition of function printline. *

// This function has two parameters: line and startCount. *

// The string pointed to by line is printed. startCount is the *

// starting position of the line in an character field. There *

// are -character left and right margins within the *

// character field. The function performs word-wrap by looking *

// for space character within the line at or after the th *

// character. A new line is started when a space is found, or the *

// end of the field is reached. *

//*******************************************************************

void printline(const char *line, int &startCount)

{

int charCount = ;

if (startCount >= ) // If the line is already at

{ // or past the right margin...

cout << "\n"; // Sart a new line.

startCount = ; // Reset startCount.

}

// The following while loop cycles through the string

// printing it one character at a time. It watches for

// spaces after the th position so word-wrap may be

// performed.

while (line[charCount] != '\')

{

if (startCount >= && line[charCount] == ' ')

{

cout << " \n"; // Print right margin.

charCount++; // Skip over the space.

startCount = ;

}

if (startCount == )

{

cout << " "; // Print left margin.

startCount = ;

}

cout.put(line[charCount]); // Print the character.

charCount++; // Update subscript.

startCount++; // Update position counter.

}

}

String Manipulation
Program -
(continued)
Program Output with Example Input Shown in Bold
Salutation:
) Mr.
) Ms.
Select one:
[Enter]
Last name:
Jones [Enter]
Account balance:
. [Enter]
Past due amount:
. [Enter]
Date of last payment(MM/DD/YYYY):
// [Enter]
Dear Mr. Jones:
Our records show that your account has a balance of
$. and a past due amount of $.. Your last
payment was on //. Since we haven't heard from
you in some time, would you please take a moment to
send us a check for the past-due amount? We value your business
and look forward to serving you in the future.
Sincerely,
The Management
P.S. If you've already sent your payment, ignore this
reminder.
Do another letter? (Y/N)
y [Enter]
Salutation:
) Mr.
) Ms.
Select one:
[Enter]
Last name:
Hildebrand [Enter]
Account balance:
,. [Enter]
Past due amount:
,. [Enter]
Date of last payment(MM/DD/YYYY):
// [Enter]
Dear Ms. Hildebrand:
Our records show that your account has a balance of
$,. and a past due amount of $,.. Your
last payment was on //. Since we haven't heard
from you in some time, would you please take a moment
to send us a check for the past-due amount? We value
your business and look forward to serving you in the
future.
Sincerely,
The Management
P.S. If you've already sent your payment, ignore this
reminder.
Do another letter? (Y/N)
n [Enter]

String Class Implementation

2008-12-12T20:58:00.000-08:00

Earlier in this book you were introduced to the C++ standard library
class. The string class automatically handles many of the tedious tasks involved in using strings,
string such as dynamic memory allocation, and bounds checking. It also overloads operators,
such as and , and offers many member functions that ease the job of working with + =
strings. In this section, however, you will learn to write your own string handling class. In
the process, you will see examples of the copy constructor and overloaded operators in
full action.

The MyString Class
The class defined in this section is an abstract data type for handling strings. It
MyString offers several advantages over standard C++ character array manipulation:

• Memory is dynamically allocated for any string stored in a object. The MyString programmer using this class doesn’t need to be concerned with how large to make
an array.
• Strings may be assigned to a object with the = operator. The program-
MyString mer using this class does not have to call the function.
strcpy
• One string may be concatenated to another with the += operator. This eliminates the need for the function.
strcat
• Strings may be tested with the relational operators. The programmer using this class doesn’t have to call the function.

strcmp

The following program listings show the class implementation.
Contents of
MyString.h

// Specification file for the MyString class

#ifndef MYSTRING_H

#define MYSTRING_H

#include

using namespace std;

Creating a String Class

class MyString; // Forward declaration.

ostream &operator<<(ostream &, const MyString &);

istream &operator>>(istream &, MyString &);

// MyString class. An abstract data type for handling strings.

class MyString

{

private:

char *str;

int len;

public:

// Default constructor

MyString()

{ str = NULL; len = ; }

// Copy constructor

MyString(MyString &right)

{ str = new char[right.length() + ];

strcpy(str, right.getValue());

len = right.length(); }

// The following constructor initializes the

// MyString object with a C-string

MyString(char *sptr)

{ len = strlen(sptr);

str = new char[len + ];

strcpy(str, sptr); }

// Destructor

~MyString()

{ if (len != ) delete [] str; }

// The length function returns the string length.

int length() const

{ return len; }

// The getValue function returns the string.

const char *getValue() const

{ return str; };

// Overloaded operators

const MyString operator+=(MyString &);

const char *operator+=(const char *);

const MyString operator=(MyString &);

const char *operator=(const char *);

int operator==(MyString &);

int operator==(const char *);

int operator!=(MyString &);

int operator!=(const char *);

bool operator>(MyString &);

bool operator>(const char *);

bool operator<(MyString &);

Creating a String Class

bool operator<(const char *);

bool operator>=(MyString &);

bool operator>=(const char*);

bool operator<=(MyString &);

bool operator<=(const char *);

// Friends

friend ostream &operator<<(ostream &, const MyString &);

friend istream &operator>>(istream &, MyString &);

};

#endif
Contents of
MyString.cpp

// Implementation file for the MyString class

#include // For string library functions

#include "MyString.h"

using namespace std;

//*************************************************

// Overloaded = operator. Called when operand *

// on the right is another MyString object. *

// Returns the calling object. *

//*************************************************

const MyString MyString::operator=(MyString &right)

{

if (len != )

delete [] str;

str = new char[right.length() + ];

strcpy(str, right.getValue());

len = right.length();

return *this;

}

//*************************************************

// Overloaded = operator. Called when operand *

// on the right is a C-string. *

// Returns the str member of the calling object. *

//*************************************************

const char *MyString::operator=(const char *right)

{

if (len != )

delete [] str;

len = strlen(right);

str = new char[len + ];

strcpy(str, right);

return str;

}

Creating a String Class

//*************************************************

// Overloaded += operator. Called when operand *

// on the right is another MyString object. *

// Concatenates the str member of right to the *

// str member of the calling object. *

// Returns the calling object. *

//*************************************************

const MyString MyString::operator+=(MyString &right)

{

char *temp = str;

str = new char[strlen(str) + right.length() + ];

strcpy(str, temp);

strcat(str, right.getValue());

if (len != )

delete [] temp;

len = strlen(str);

return *this;

}

//*************************************************

// Overloaded += operator. Called when operand *

// on the right is a string. Concatenates the *

// str member of right to the str member of *

// the calling object. *

// Returns the str member of the calling object. *

//*************************************************

const char *MyString::operator+=(const char *right)

{

char *temp = str;

str = new char[strlen(str) + strlen(right) + ];

strcpy(str, temp);

strcat(str, right);

if (len != )

delete [] temp;

return str;

}

//*****************************************************

// Overloaded == operator. *

// Called when the operand on the right is a MyString *

// object. Returns if right.str is the same as str. *

//*****************************************************

int MyString::operator==(MyString &right)

{

return !strcmp(str, right.getValue());

}

Creating a String Class

//****************************************************

// Overloaded == operator. *

// Called when the operand on the right is a string. *

// Returns if right is the same as str. *

//****************************************************

int MyString::operator==(const char *right)

{

return !strcmp(str, right);

}

//*********************************************************

// Overloaded != operator. *

// Called when the operand on the right is a MyString *

// object. Returns true if right.str is not equal to str. *

//*********************************************************

int MyString::operator!=(MyString &right)

{

return strcmp(str, right.getValue());

}

//****************************************************

// Overloaded != operator. *

// Called when the operand on the right is a string. *

// Returns true if right is not equal to str. *

//****************************************************

int MyString::operator!=(const char *right)

{

return strcmp(str, right);

}

//*********************************************************

// Overloaded > operator. *

// Called when the operand on the right is a MyString *

// object. Returns true if str is greater than right.str. *

//*********************************************************

bool MyString::operator>(MyString &right)

{

bool status;

if (strcmp(str, right.getValue()) > )

status = true;

else

status = false;

return status;

}

//****************************************************

// Overloaded > operator. *

// Called when the operand on the right is a string. *

// Returns true if str is greater than right. *

//****************************************************

Creating a String Class

bool MyString::operator>(const char *right)

{

bool status;

if (strcmp(str, right) > )

status = true;

else

status = false;

return status;

}

//******************************************************

// Overloaded < operator. *

// Called when the operand on the right is a MyString *

// object. Returns true if str is less than right.str. *

//******************************************************

bool MyString::operator<(MyString &right)

{

bool status;

if (strcmp(str, right.getValue()) < )

status = true;

else

status = false;

return status;

}

//****************************************************

// Overloaded < operator. *

// Called when the operand on the right is a string. *

// Returns true if str is less than right. *

//****************************************************

bool MyString::operator<(const char *right)

{

bool status;

if (strcmp(str, right) < )

status = true;

else

status = false;

return status;

}

//*****************************************************

// Overloaded >= operator. *

// Called when the operand on the right is a MyString *

// object. Returns true if str is greater than or *

// equal to right.str *

//*****************************************************

bool MyString::operator>=(MyString &right)

{

bool status;

Creating a String Class

if (strcmp(str, right.getValue()) >= )

status = true;

else

status = false;

return status;

}

//*********************************************************

// Overloaded >= operator. *

// Called when the operand on the right is a string. *

// Returns true if str is greater than or equal to right. *

//*********************************************************

bool MyString::operator>=(const char *right)

{

bool status;

if (strcmp(str, right) >= )

status = true;

else

status = false;

return status;

}

//**********************************************************

// Overloaded <= operator. *

// Called when the operand on the right is a MyString *

// object. Returns true if right.str is less than or equal *

// to right.str. *

//**********************************************************

bool MyString::operator<=(MyString &right)

{

bool status;

if (strcmp(str, right.getValue()) <= )

status = true;

else

status = false;

return status;

}

//******************************************************

// Overloaded <= operator. *

// Called when the operand on the right is a string. *

// Returns true if str is less than or equal to right. *

//******************************************************

bool MyString::operator<=(const char *right)

{

bool status;

if (strcmp(str, right) <= )

status = true;

else

status = false;

Creating a String Class

return status;

}

//*************************************************

// Overloaded stream insertion operator (<<). *

//*************************************************

ostream &operator<<(ostream &strm, const MyString &obj)

{

strm << obj.str;

return strm;

}

//*************************************************

// Overloaded stream extraction operator (>>). *

//*************************************************

istream &operator>>(istream &strm, MyString &obj)

{

strm.getline(obj.str, obj.len);

strm.ignore();

return strm;

}
The Copy Constructor
Because the
class has a pointer as a member and dynamically allocates memory
MyString
to store its string value, a copy constructor is provided. This function will cause the object
to properly set up its data when initialized with another
object.
MyString
The Overloaded = Operators
The
class has two overloaded = operators. The first is for assigning one
MyString
object to another. This operator function is called when the operand on the
MyString
right of the = sign is a
object, as shown in the following code segment:
MyString
MyString first("Hello"), second;
second = first;
The second version of
’s = operator is for assigning a traditional C-string to a
MyString
object. This operator function is called when the operand on the right of = is a
MyString
string literal or any pointer to a C-string (such as the name of a char array). This is shown
in the following program segment:
MyString name;
char who[] = "Jimmy";
name = who;
The Overloaded += Operators
The += operator is designed to concatenate the string on its right to the
object
MyString
on its left. Like the = operators,
has two versions of +=. The first version is
MyString
designed to work when the right operand is another
object, as shown in the fol-
MyString
lowing program segment:

Creating a String Class
MyString first("Hello "), second("world");
first += second;
The second version of the += operator will be called when the right operand is a literal
string or any pointer to a character. It is shown here:
MyString first("Hello ");
first += "World";
The Overloaded == Operators
The
object has overloaded versions of the == operator for performing equality
MyString
tests. Like the other operators, the first version is designed to work with another
object and the second is designed to work with a traditional C-string.
MyString
The
operator functions return an integer that can be treated as a Boolean value. Both
==
functions use
to compare the operands, and then returns the negative of
’s
strcmp
strcmp
return value. (Recall that
uses inverted logic: It returns when its arguments are
strcmp
equal, and returns a nonzero value when they are not equal.) So, these operator functions
return
if the string contained in the right operand matches the
member of the
true
str
calling object. If the strings of the two operands do not match, the functions return
.
false
These operator functions allow the programmer using this class to construct relational
expressions such as those shown in the following program segments:
MyString name("John"), name("John");
if (name == name)
cout << "The names are the same.\n";
else
cout << "The names are different.\n";
MyString name("John");
if (name == "Jon")
cout << "The names are the same.\n";
else
cout << "The names are different.\n";
The Overloaded > and < Operators
The
object has two overloaded versions of the
operator for performing
MyString
>
greater-than tests, and the < operator for performing less-than tests. The first version of
each is designed to work with another
object and the second is designed to
MyString
work with a traditional C-string. (The functions use the library function
to deter-
strcmp
mine if a greater-than or less-than relationship exists.)
The > functions return a
if the
member of the calling object is greater than the
true
str
string contained in the right operand. Otherwise, the functions return
. The < func-
false
tions return a
if the
member of the calling object is less than the string contained
true
str
in the right operand. Otherwise, they return
.
false
These operator functions allow the programmer using this class to construct relational
expressions such as those shown in the following program segments:
MyString name("John"), name("Jon");
if (name > name)

Creating a String Class
cout << "John is greater than Jon.\n";
else
cout << "John is not greater than Jon.\n";
MyString name("John");
if (name < "Jon")
cout << "John is less than Jon.\n";
else
cout << "John is not greater than Jon.\n";
The Overloaded >= and <= Operators
The
object has two overloaded versions of the >= operator for performing
MyString
greater-than or equal-to tests, and the <= operator for performing less-than or equal-to
tests. The first version of each is designed to work with another
object and the
MyString
second is designed to work with a traditional C-string. (The functions use the library func-
tion
to determine if a greater-than or less-than relationship exists.)
strcmp
The >= functions return a
if the
member of the calling object is greater than or
true
str
equal to the string contained in the right operand. Otherwise, the functions return
.
false
The <= functions return
if the
member of the calling object is less than or equal
true
str
to the string contained in the right operand. Otherwise, they return
.
false
These operator functions allow the programmer using this class to construct relational
expressions such as those shown in the following program segments:
MyString name("John"), name("Jon");
if (name >= name)
cout << "John is greater than or equal to Jon.\n";
else
cout << "John is not greater than or equal to Jon.\n";
MyString name("John");
if (name <= "Jon")
cout << "John is less than or equal to Jon.\n";
else
cout << "John is not less than or equal to Jon.\n";
Program - shows how
’s += operator performs string concatenation. Addi-
MyString
tionally, the program’s source code demonstrates how
allows the programmer
MyString
to treat strings much like any other built-in data type.
Program -

// This program demonstrates the MyString class.

#include

#include "MyString.h"

int main()

{

// Define and initialize several MyString objects.

MyString object("This"), object("is");

MyString object("a test.");

MyString object = object;

MyString object("is only a test.");
(program continues)

Creating a String Class
Program -
(continued)

// Define a C-string.

char string[] = "a test.";

// Display the MyString objects.

cout << "object: " << object << endl;

cout << "object: " << object << endl;

cout << "object: " << object << endl;

cout << "object: " << object << endl;

cout << "object: " << object << endl;

// Display the C-string.

cout << "string: " << string << endl;

// Test the overloaded += operator.

object += " ";

object += object;

object += " ";

object += object;

object += " ";

object += object;

object += " ";

object += object;

cout << "object: " << object << endl;

return ;

}
Program Output
object: This
object: is
object: a test.
object: This
object: is only a test.
string: a test.
object: This is a test. This is only a test.
Program - shows how
’s relational operators can be used to compare
MyString
strings with the same ease that numeric data types are compared.
Program -

// This program demonstrates the MyString class.

#include

#include "MyString.h"

using namespace std;

int main()

{

// Define several MyString objects.

MyString name("Billy"), name("Sue");

MyString name("joe");

MyString string("ABC"), string("DEF");

(program continues)

Creating a String Class
Program -
(continued)

// Display the MyString object values.

cout << "name: " << name.getValue() << endl;

cout << "name: " << name.getValue() << endl;

cout << "name: " << name.getValue() << endl;

cout << "string: " << string.getValue() << endl;

cout << "string: " << string.getValue() << endl;

// Test the overloaded relational operators.

if (name == name)

cout << "name is equal to name.\n";

else

cout << "name is not equal to name.\n";

if (name == "joe")

cout << "name is equal to joe.\n";

else

cout << "name is not equal to joe.\n";

if (string > string)

cout << "string is greater than string.\n";

else

cout << "string is not greater than string.\n";

if (string < string)

cout << "string is less than string.\n";

else

cout << "string is not less than string.\n";

if (string >= string)

cout << "string is greater than or equal to string.\n";

else

cout << "string is not greater than or equal to string.\n";

if (string >= "ABC")

cout << "string is greater than or equal to ABC.\n";

else

cout << "string is not greater than or equal to ABC.\n";

if (string <= string)

cout << "string is less than or equal to string.\n";

else

cout << "string is not less than or equal to string.\n";

if (string <= "DEF")

cout << "string is less than or equal to DEF.\n";

else

cout << "string is not less than or equal to DEF.\n";

return ;

}

Creating a String Class
Program -
(continued)
Program Output
name: Billy
name: Sue
name: joe
string: ABC
string: DEF
name is not equal to name.
name is equal to joe.
string is not greater than string.
string is less than string.
string is not greater than or equal to string.
string is greater than or equal to ABC.
string is less than or equal to string.
string is less than or equal to DEF.

Namespaces

2008-12-11T06:47:00.000-08:00

Introduction
Namespaces are an ANSI C++ feature that allows programmers to create a scope for global
identifiers. They are useful in preventing errors when two or more global declarations
use the same name.
For example, assume you are a programmer in the accounting department of a business.
Your company has purchased two libraries of C++ code from a software vendor. One of
the libraries is designed to handle customer accounts, and contains a class object named
payable
. The other library is designed to handle company payroll, and also has a class
object named
payable
. You are writing a program that integrates both libraries, but the
compiler generates an error because the two class objects have the same name. You cannot
modify the libraries because the software vendor does not sell the source code, only libraries
of object code.
This problem can be solved when the software vendor places each library in its own
namespace. Each namespace has its own name, which must be used to qualify the name of
its members. For instance, the
payable
object that is part of the customer accounts library
might exist in a namespace named
customer
, while the object that is part of the employee
payroll library might exist in a namespace named
payroll
. When you, the application
programmer, work with the objects, you must specify the namespace that the object is a
member of. One way of accomplishing this is by extending the name of the object with the
namespace name, using the scope resolution operator. For example, the
payable
object
that is a member of the
customer
namespace is specified as
customer::payable
, and the
object that is a member of the
payroll
namespace is specified as
payroll::payable
.
Another way to specify the namespace is by placing a
using namespace
statement in the
source file that references the namespace’s member object. For example, the following
statement (placed near the beginning of a source file) instructs the compiler that the file
uses members of the
customer
namespace.
using namespace customer;
2
Appendix F: Namespaces
Likewise, the following statement instructs the compiler that the source file uses members
of the
payroll
namespace:
using namespace payroll;
When a
using namespace
statement has been placed in a source file, it is no longer necessary
for statements in that source file to qualify the names of the namespace’s members
with the namespace name and the scope resolution operator.
Defining a Namespace
A namespace is defined in the following manner.
For example, look at Program F-1. It defines the
test
namespace, which has three members:
x
,
y
, and
z
.
In Program F-1, the variables
x
,
y
, and
z
are defined in the
test
namespace’s scope. Each
time the program accesses one of these variables,
test::
must precede the variable name.
Otherwise, a compiler error will occur.
namespace
namespace_name
{
declarations…
}
Program F-1
1 // Demonstrates a simple namespace
2 #include
3 using namespace std;
4
5 namespace test
6 {
7 int x, y, z;
8 }
9
10 int main()
11 {
12 test::x = 10;
13 test::y = 20;
14 test::z = 30;
15 cout << "The values are:\n";
16 cout << test::x << " " << test::y
17 << " " << test::z << endl;
18 return 0;
19 }
Program Output
The values are:
10 20 30
Appendix F: Namespaces
3
Program F-2 demonstrates how programmers can use namespaces to resolve naming
conflicts. The program defines two namespaces,
test1
and
test2
. Both namespaces have
variables named
x
,
y
, and
z
as members.
An alternative approach to qualifying the names of namespace members is to use the
using
namespace
statement. This statement tells the compiler which namespace to search
for an identifier, when the identifier cannot be found in the current scope. Program F-3
demonstrates the statement.
Program F-2
1 // Demonstrates two namespaces
2 #include
3 using namespace std;
4
5 namespace test1
6 {
7 int x, y, z;
8 }
9
10 namespace test2
11 {
12 int x, y, z;
13 }
14
15 int main()
16 {
17 test1::x = 10;
18 test1::y = 20;
19 test1::z = 30;
20 cout << "The test1 values are:\n";
21 cout << test1::x << " " << test1::y
22 << " " << test1::z << endl;
23 test2::x = 1;
24 test2::y = 2;
25 test2::z = 3;
26 cout << "The test2 values are:\n";
27 cout << test2::x << " " << test2::y
28 << " " << test2::z << endl;
29 return 0;
30 }
Program Output
The test1 values are:
10 20 30
The test2 values are:
1 2 3
4
Appendix F: Namespaces
The
using namespace demo;
statement eliminates the need to precede
testObject
with
demo::
. The compiler automatically uses the namespace demo to find the identifier.
ANSI C++ and the
std
Namespace
All the identifiers in the ANSI standard header files are part of the
std
namespace. In
ANSI C++,
cin
and
cout
are written as
std::cin
and
std::cout
. If you do not wish to
specify
std::
with
cin
or
cout
(or any of the ANSI standard identifiers), you must write
the following statement in your program:
using namespace std;
Program F-3
Contents of
nsdemo.h
1 // This file defines a namespace named demo.
2 // In the demo namespace a class named NsDemo
3 // is declared, and an instance of the class
4 // named testObject is defined.
5
6 namespace demo
7 {
8 class NsDemo
9 {
10 public:
11 int x, y, z;
12 };
13
14 NsDemo testObject;
15 }
Contents of Main File,
PrF-3.cpp
1 // A demonstration of the using namespace statement.
2 #include
3 #include "nsdemo.h"
4 using namespace std;
5 using namespace demo;
6
7 int main()
8 {
9 testObject.x = 10;
10 testObject.y = 20;
11 testObject.z = 30;
12 cout << "The values are:\n"
13 << testObject.x << " "
14 << testObject.y << " "
15 << testObject.z << endl;
16 return 0;
17 }
Program Output
The values are:
10 20 30

The `fork()' system call

2008-12-08T17:47:00.001-08:00

From the C programming language, the fork() system call is well known. When a program needs to start a new process, system() can be used, but this requires the program to wait for the child process to terminate. The more general way to spawn subprocesses is to call fork().

In this section we will see how C++ can be used to wrap classes around a complex system call like fork(). Much of what follows in this section directly applies to the Unix operating system, and the discussion will therefore focus on that operating system. However, other systems usually provide comparable facilities. The following discussion is based heavily on the notion of design patterns, as published by Gamma et al. (1995)

When fork() is called, the current program is duplicated in memory, thus creating a new process, and both processes continue their execution just below the fork() system call. The two processes may, however, inspect the return value of fork(): the return value in the original process (called the parent process) differs from the return value in the newly created process (called the child process):

In the parent process fork() returns the process ID of the child process created by the fork() system call. This is a positive integer value.
In the child process fork() returns 0.
If fork() fails, -1 is returned.

A basic Fork class should hide all bookkeeping details of a system call like fork() from its users. The class Fork developed here will do just that. The class itself only needs to take care of the proper execution of the fork() system call. Normally, fork() is called to start a child process, usually boiling down to the execution of a separate process. This child process may expect input at its standard input stream and/or may generate output to its standard output and/or standard error streams. Fork does not know all this, and does not have to know what the child process will do. However, Fork objects should be able to activate their child processes.

Unfortunately, Fork's constructor cannot know what actions its child process should perform. Similarly, it cannot know what actions the parent process should perform. For this particular situation, the template method design pattern was developed. According to Gamma c.s., the template method design pattern

``Define(s) the skeleton of an algorithm in an operation, deferring some steps to subclasses. (The) Template Method (design pattern) lets subclasses redefine certain steps of an algorithm, without changing the algorithm's structure.''

This design pattern allows us to define an abstract base class already implementing the essential steps related to the fork() system call and deferring the implementation of certain normally used parts of the fork() system call to subclasses.

The Fork abstract base class itself has the following characteristics:

It defines a data member d_pid. This data member will contain the child's process id (in the parent process) and the value 0 in the child process:

· class Fork

· {

· int d_pid;

Its public interface declares but two members:

a fork() member function, performing the actual forking (i.e., it will create the (new) child process);
an empty virtual destructor ~Fork(), which may be overridden by derived classes.

Here is Fork's complete public interface:

virtual ~Fork()

{}

void fork();

All remaining member functions are declared in the class's protected section and can thus only be used by derived classes. They are:

The member function pid(), allowing derived classes to access the system fork()'s return value:

o int pid()

o {

o return d_pid;

o }

A member int waitForChild(), which can be called by parent processes to wait for the completion of their child processes (as discussed below). This member is declared in the class interface. Its implementation is

o #include "fork.ih"

o int Fork::waitForChild()

o {

o int status;

o waitpid(d_pid, &status, 0);

o return WEXITSTATUS(status);

o }

This simple implementation returns the child's exit status to the parent. The called system function waitpid() blocks until the child terminates.

When fork() system calls are used, parent processes and child processes may always be distinguished. The main distinction between these processes is that d_pid will be equal to the child's process-id in the parent process, while d_pid will be equal to 0 in the child process itself. Since these two processes may always be distinguished, they must be implemented by classes derived from Fork. To enforce this requirement, the members childProcess(), defining the child process' actions and parentProcess(), defining the parent process' actions we defined as pure virtual functions:

o virtual void childProcess() = 0; // both must be implemented

o virtual void parentProcess() = 0;

In addition, communication between parent- and child processes may use standard streams or other facilities, like pipes (cf. section 20.3.3). To facilitate this inter-process communication, derived classes may implement:

childRedirections(): this member should be implemented if any standard stream (cin, cout) or cerr must be redirected in the child process (cf. section 20.3.1);
parentRedirections(): this member should be implemented if any standard stream (cin, cout) or cerr must be redirected in the parent process.

Redirection of the standard streams will be necessary if parent- and child processes should communicate with each other via the standard streams. Here are their default definitions provided by the class's interface:

virtual void childRedirections()

{}

virtual void parentRedirections()

{}

The member function fork() calls the system function fork() (Caution: since the system function fork() is called by a member function having the same name, the :: scope resolution operator must be used to prevent a recursive call of the member function itself). After calling ::fork(), depending on its return value, either parentProcess() or childProcess() is called. Maybe redirection is necessary. Fork::fork()'s implementation calls childRedirections() just before calling childProcess(), and parentRedirections() just before calling parentProcess():

#include "fork.ih"

void Fork::fork()

{

if ((d_pid = ::fork()) <>

throw "Fork::fork() failed";

if (d_pid == 0) // childprocess has pid == 0

{

childRedirections();

childProcess();

exit(1); // we shouldn't come here:

// childProcess() should exit

}

parentRedirections();

parentProcess();

}

In fork.cc the class's internal header file fork.ih is included. This header file takes care of the inclusion of the necessary system header files, as well as the inclusion of fork.h itself. Its implementation is:

#include "fork.h"

#include

Child processes should not return: once they have completed their tasks, they should terminate. This happens automatically when the child process performs a call to a member of the exec...() family, but if the child itself remains active, then it must make sure that it terminates properly. A child process normally uses exit() to terminate itself, but it should be realized that exit() prevents the activation of destructors of objects defined at the same or more superficial nesting levels than the level at which exit() is called. Destructors of globally defined objects are activated when exit() is used. When using exit() to terminate childProcess(), it should either itself call a support member function defining all nested objects it needs, or it should define all its objects in a compound statement (e.g., using a throw block) calling exit() beyond the compound statement.

Parent processes should normally wait for their children to complete. The terminating child processes inform their parent that they are about to terminate by sending out a signal which should be caught by their parents. If child processes terminate and their parent processes do not catch those signal then such child processes remain visible as so-called zombie processes.

If parent processes must wait for their children to complete, they may call the member waitForChild(). This member returns the exit status of a child process to its parent.

There exists a situation where the child process continues to live, but the parent dies. In nature this happens all the time: parents tend to die before their children do. In our context (i.e. C++), this is called a daemon program: the parent process dies and the child program continues to run as a child of the basic init process. Again, when the child eventually dies a signal is sent to its `step-parent' init. No zombie is created here, as init catches the termination signals of all its (step-) children. The construction of a daemon process is very simple, given the availability of the class Fork (cf. section 20.3.2).

Classes for input operations

2008-12-08T17:45:00.000-08:00

To derive a class doing input operations from std:: streambuf, the class should use an input buffer of at least one character, to allow the use of the member functions istream::putback() or istream::ungetc(). Stream classes (like istream) normally allow us to unget at least one character using their member functions putback() or ungetc(). This is important, as these stream classes usually interface to streambuf objects. Although it is strictly speaking not necessary to implement a buffer in classes derived from streambuf, using buffers in these cases is strongly advised: the implementation is very simple and straightforward, and the applicability of such classes will be greatly improved. Therefore, in all our classes derived from the class streambuf at least a buffer of one character will be defined.

Using a one-character buffer When deriving a class (e.g., ifdstreambuf) from streambuf using a buffer of one character, at least its member streambuf::underflow() should be overridden, as this is the member to which all requests for input are eventually directed. Since a buffer is also needed, the member streambuf::setg() is used to inform the streambuf base class of the size of the input buffer, so that it is able to set up its input buffer pointers correctly. This will ensure that eback(), gptr(), and egptr() return correct values.

The required class shows the following characteristics:

Like the class designed for output operations, this class is derived from std:: streambuf as well:

· class ifdstreambuf: public std::streambuf

The class receives two data members, one of them a fixed-sized one character buffer. The data members are defined as protected data members so that derived classes (e.g., see section 20.1.2.3) can access them:

· protected:

· int d_fd;

· char d_buffer[1];

The constructor initializes the buffer. However, this initialization is done so that gptr() will be equal to egptr(). Since this implies that the buffer is empty, underflow() will immediately be called to refill the buffer:

· ifdstreambuf(int fd)

· :

· d_fd(fd)

· {

· setg(d_buffer, d_buffer + 1, d_buffer + 1);

· }

Finally underflow() is overridden. It will first ensure that the buffer is really empty. If not, then the next character in the buffer is returned. If the buffer is really empty, it is refilled by reading from the file descriptor. If this fails (for whatever reason), EOF is returned. More sophisticated implementations could react more intelligently here, of course. If the buffer could be refilled, setg() is called to set up streambuf's buffer pointers correctly.
The implementations of the member functions use low-level functions to operate the file descriptors, so apart from streambuf the header file unistd.h must have been read by the compiler before the implementations of the member functions can be compiled.

This completes the construction of the ifdstreambuf class. It is used in the following program:

#include

#include "ifdbuf.h"

using namespace std;

int main(int argc)

{

ifdstreambuf fds(STDIN_FILENO);

istream is(&fds);

cout <<>

}

Using an n-character buffer How complex would things get if we would decide to use a buffer of substantial size? Not that complex. The following class allows us to specify the size of a buffer, but apart from that it is basically the same class as ifdstreambuf developed in the previous section. To make things a bit more interesting, in the class ifdnstreambuf developed here, the member streambuf::xsgetn() is also overridden, to optimize reading of series of characters. Furthermore, a default constructor is provided which can be used in combination with the open() member to construct an istream object before the file descriptor becomes available. Then, once the descriptor becomes available, the open() member can be used to initiate the object's buffer. Later, in section 20.3, we'll encounter such a situation.

To save some space, the success of various calls was not checked. In `real life' implementations, these checks should, of course, not be omitted. The class ifdnstreambuf has the following characteristics:

Once again, it is derived from std:: streambuf:

· class ifdnstreambuf: public std::streambuf

Like the class ifdbuf (section 20.1.2.1), its data members are protected. Since the buffer's size is configurable, this size is kept in a dedicated data member, d_bufsize:

· protected:

· int d_fd;

· unsigned d_bufsize;

· char* d_buffer;

The default constructor does not allocate a buffer, and can be used to construct an object before the file descriptor becomes known. A second constructor simply passes its arguments to open() which will then initialize the object so that it can actually be used:

· ifdnstreambuf()

· :

· d_bufsize(0),

· d_buffer(0)

· {}

· ifdnstreambuf(int fd, unsigned bufsize = 1)

· {

· open(fd, bufsize);

· }

If the object has been initialized by open(), its destructor will both delete the object's buffer and use the file descriptor to close the device:

· ~ifdnstreambuf()

· {

· if (d_bufsize)

· {

· close(d_fd);

· delete[] d_buffer;

· }

The open() member simply allocates the object's buffer. It is assumed that the calling program has already opened the device. Once the buffer has been allocated, the base class member setg() is used to ensure that eback(), gptr(), and egptr() return correct values:

· void open(int fd, unsigned bufsize = 1)

· {

· d_fd = fd;

· d_bufsize = bufsize;

· d_buffer = new char[d_bufsize];

· setg(d_buffer, d_buffer + d_bufsize, d_buffer + d_bufsize);

· }

The overridden member underflow() is implemented almost identically to ifdstreambuf's (section 20.1.2.1) member. The only difference is that the current class supports a buffer of larger sizes. Therefore, more characters (up to d_bufsize) may be read from the device at once:

· int underflow()

· {

· if (gptr() <>

· return *gptr();

· int nread = read(d_fd, d_buffer, d_bufsize);

· if (nread <= 0)

· return EOF;

· setg(d_buffer, d_buffer, d_buffer + nread);

· return *gptr();

· }

Finally xsgetn() is overridden. In a loop, n is reduced until 0, at which point the function terminates. Alternatively, the member returns if underflow() fails to obtain more characters. This member optimizes the reading of series of characters: instead of calling streambuf::sbumpc() n times, a block of avail characters is copied to the destination, using streambuf::gpumb() to consume avail characters from the buffer using one function call:

· std::streamsize xsgetn(char *dest, std::streamsize n)

· {

· int nread = 0;

· while (n)

· {

· if (!in_avail())

· {

· if (underflow() == EOF)

· break;

· }

· int avail = in_avail();

· if (avail > n)

· avail = n;

· memcpy(dest + nread, gptr(), avail);

· gbump(avail);

· nread += avail;

· n -= avail;

· }

· return nread;

· }

The implementations of the member functions use low-level functions to operate the file descriptors. So apart from streambuf the header file unistd.h must have been read by the compiler before the implementations of the member functions can be compiled.

The member function xsgetn() is called by streambuf::sgetn(), which is a streambuf member. The following example illustrates the use of this member function with a ifdnstreambuf object:

#include

#include "ifdnbuf.h"

using namespace std;

int main(int argc)

{

// internally: 30 char buffer

ifdnstreambuf fds(STDIN_FILENO, 30);

char buf[80]; // main() reads blocks of 80

// chars

while (true)

{

unsigned n = fds.sgetn(buf, 80);

if (n == 0)

break;

cout.write(buf, n);

}

Seeking positions in `streambuf' objects When devices support seek operations, classes derived from streambuf should override te members streambuf::seekoff() and streambuf::seekpos(). The class ifdseek, developed in this section, can be used to read information from devices supporting such seek operations. The class ifdseek was derived from ifdstreambuf, so it uses a character buffer of just one character. The facilities to perform seek operations, which are added to our new class ifdseek, will make sure that the input buffer is reset when a seek operation is requested. The class could also be derived from the class ifdnstreambuf; in which case, the arguments to reset the input buffer must be adapted in such a way that its second and third parameters point beyond the available input buffer. Let's have a look at the characteristics of ifdseek:

As mentioned, ifdseek is derived from ifdstreambuf. Like the latter class, ifdseek's member functions use facilities declared in unistd.h. So, the compiler must have seen unistd.h before it can compile the class's members functions. The class interface itself starts with:

· class ifdseek: public ifdstreambuf

To reduce the amount of typing when specifying types and constants from std::streambuf and std::ios, several typedefs are defined at the class's very top:

· typedef std::streambuf::pos_type pos_type;

· typedef std::streambuf::off_type off_type;

· typedef std::ios::seekdir seekdir;

· typedef std::ios::openmode openmode;

These typedefs refer to types that are defined in the header file ios, which must therefore be included as well before the compiler reads ifdseek's class definition.

The class is given a rather basic implementation. The only required constructor expects the device's file descriptor. It has no special tasks to perform and only needs to call its base class constructor:

· ifdseek(int fd)

· :

· ifdstreambuf(fd)

· {}

The member seek_off() is responsible for performing the actual seek operations. It calls lseek() to seek a new position in a device whose file descriptor is known. If seeking succeeds, setg() is called to define an already empty buffer, so that the base class's underflow() member will refill the buffer at the next input request.

· pos_type seekoff(off_type offset, seekdir dir, openmode)

· {

· pos_type pos =

· lseek

· (

· d_fd, offset,

· (dir == std::ios::beg) ? SEEK_SET :

· (dir == std::ios::cur) ? SEEK_CUR :

· SEEK_END

· );

· if (pos <>

· return -1;

· setg(d_buffer, d_buffer + 1, d_buffer + 1);

· return pos;

· }

Finally, the companion function seekpos is overridden as well: it is actually defined as a call to seekoff():

· pos_type seekpos(pos_type offset, openmode mode)

· {

· return seekoff(offset, std::ios::beg, mode);

· }

An example of a program using the class ifdseek is the following. If this program is given its own source file using input redirection then seeking is supported, and with the exception of the first line, every other line is shown twice:

#include "fdinseek.h"

#include

using namespace std;

int main(int argc)

{

ifdseek fds(0);

istream is(&fds);

string s;

while (true)

{

if (!getline(is, s))

break;

streampos pos = is.tellg();

cout <<>

if (!getline(is, s))

break;

streampos pos2 = is.tellg();

cout <<>

if (!is.seekg(pos))

{

cout << "Seek failed\n";

break;

}

20.1.2.4: Multiple `unget()' calls in `streambuf' objects As mentioned before, streambuf classes and classes derived from streambuf should support at least ungetting the last read character. Special care must be taken when series of unget() calls must be supported. In this section the construction of a class supporting a configurable number of istream::unget() or istream::putback() calls.

Support for multiple (say `n') unget() calls is realized by reserving an initial section of the input buffer, which is gradually filled up to contain the last n characters read. The class was implemented as follows:

Once again, the class is derived from std:: streambuf. It defines several data members, allowing the class to perform the bookkeeping required to maintain an unget-buffer of a configurable size:

· class fdunget: public std::streambuf

· {

· int d_fd;

· unsigned d_bufsize;

· unsigned d_reserved;

· char* d_buffer;

· char* d_base;

The class's constructor expects a file descriptor, a buffer size and the number of characters that can be ungot or pushed back as its arguments. This number determines the size of a reserved area, defined as the first d_reserved bytes of the class's input buffer.

The input buffer will always be at least one byte larger than d_reserved. So, a certain number of bytes may be read. Then, once reserved bytes have been read at least reserved bytes can be ungot.
Next, the starting point for reading operations is configured: it is called d_base, pointing to a location reserved bytes from the start of d_buffer. This will always be the point where the buffer refills start.
Now that the buffer has been constructed, we're ready to define streambuf's buffer pointers using setg(). As no characters have been read yet, all pointers are set to point to d_base. If unget() is called at this point, no characters are available, so unget() will (correctly) fail.
Eventually, the refill buffer's size is determined as the number of allocated bytes minus the size of the reserved area.

Here is the class's constructor:

fdunget (int fd, unsigned bufsz, unsigned unget)

d_fd(fd),

d_reserved(unget)

{

unsigned allocate =

bufsz > d_reserved ?

bufsz

d_reserved + 1;

d_buffer = new char [allocate];

d_base = d_buffer + d_reserved;

setg(d_base, d_base, d_base);

d_bufsize = allocate - d_reserved;

}

The class's destructor simply returns the memory allocated for the buffer to the common pool:

· ~fdunget()

· {

· delete[] d_buffer;

· }

Finally, underflow() is overridden.

Firstly, the standard check to determine whether the buffer is really empty is applied.
If empty, it determines the number of characters that could potentially be ungot. At this point, the input buffer is exhausted. So this value may be any value between 0 (the initial state) or the input buffer's size (when the reserved area has been filled up completely, and all current characters in the remaining section of the buffer have also been read).
Next the number of bytes to move into the reserved area is computed. This number is at most d_reserved, but it is equal to the actual number of characters that can be ungot if this value is smaller.
Now that the number of characters to move into the reserved area is known, this number of characters is moved from the input buffer's end to the area immediately before d_base.
Then the buffer is refilled. This all is standard, but notice that reading starts from d_base and not from d_buffer.
Finally, streambuf's read buffer pointers are set up. Eback() is set to move locations before d_base, thus defining the guaranteed unget-area, gptr() is set to d_base, since that's the location of the first read character after a refill, and egptr() is set just beyond the location of the last character read into the buffer.

Here is underflow()'s implementation:

int underflow()

{

if (gptr() <>

return *gptr();

unsigned ungetsize = gptr() - eback();

unsigned move = std::min(ungetsize, d_reserved);

memcpy(d_base - move, egptr() - move, move);

int nread = read(d_fd, d_base, d_bufsize);

if (nread <= 0) // none read -> return EOF

return EOF;

setg(d_base - move, d_base, d_base + nread);

return *gptr();

}

};

The following program illustrates the class fdunget. It reads at most 10 characters from the standard input, stopping at EOF. A guaranteed unget-buffer of 2 characters is defined in a buffer holding 3 characters. Just before reading a character, the program tries to unget at most 6 characters. This is, of course, not possible; but the program will nicely unget as many characters as possible, considering the actual number of characters read:

#include "fdunget.h"

#include

using namespace std;

int main(int argc)

{

fdunget fds(0, 3, 2);

istream is(&fds);

char c;

for (int idx = 0; idx <>

{

cout << "after reading " <<>

for (int ug = 0; ug <= 6; ++ug)

{

if (!is.unget())

{

cout

<< "\tunget failed at attempt " << (ug + 1) << "\n"

<< "\trereading: '";

is.clear();

while (ug--)

{

is.get(c);

cout <<>

}

cout << "'\n";

break;

}

if (!is.get(c))

{

cout << " reached\n";

break;

}

cout << "Next character: " <<>

}

Generated output after 'echo abcde | program':

after reading 0 characters:

unget failed at attempt 1

rereading: ''

Next character: a

after reading 1 characters:

unget failed at attempt 2

rereading: 'a'

Next character: b

after reading 2 characters:

unget failed at attempt 3

rereading: 'ab'

Next character: c

after reading 3 characters:

unget failed at attempt 4

rereading: 'abc'

Next character: d

after reading 4 characters:

unget failed at attempt 4

rereading: 'bcd'

Next character: e

after reading 5 characters:

unget failed at attempt 4

rereading: 'cde'

Next character:

after reading 6 characters:

unget failed at attempt 4

rereading: 'de

reached

Classes for output operations

2008-12-08T17:44:00.000-08:00

Extensions to the ANSI/ISO standard may be available allowing us to read from and/or write to file descriptors. However, such extensions are not standard, and may thus vary or be unavailable across compilers and/or compiler versions. On the other hand, a file descriptor can be considered a device. So it seems natural to use the class streambuf as the starting point for constructing classes interfacing file descriptors.

In this section we will construct classes which may be used to write to a device identified by a file descriptor: it may be a file, but it could also be a pipe or socket. Section 20.1.2 discusses reading from devices given their file descriptors, while section 20.3.1 reconsiders redirection, discussed earlier in section 5.8.3.

Basically, deriving a class for output operations is simple. The only member function that must be overridden is the virtual member int overflow(int c) . This member is responsible for writing characters to the device once the class's buffer is full. If fd is a file descriptor to which information may be written, and if we decide against using a buffer then the member overflow() can simply be:

class UnbufferedFD: public std::streambuf

{

public:

int overflow(int c)

{

if (c != EOF)

{

if (write(fd, &c, 1) != 1)

return EOF;

}

return c;

}

...

}

The argument received by overflow() is either written as a value of type char to the file descriptor, or EOF is returned.

This simple function does not use an output buffer. As the use of a buffer is strongly advised (see also the next section), the construction of a class using an output buffer will be discussed next in somewhat greater detail.

When an output buffer is used, the overflow() member will be a bit more complex, as it is now only called when the buffer is full. Once the buffer is full, we first have to flush the buffer, for which the (virtual) function streambuf::sync() is available. Since sync() is a virtual function, classes derived from std::streambuf may redefine sync() to flush a buffer std::streambuf itself doesn't know about.

Overriding sync() and using it in overflow() is not all that must be done: eventually we might have less information than fits into the buffer. So, at the end of the lifetime of our special streambuf object, its buffer might only be partially full. Therefore, we must make sure that the buffer is flushed once our object goes out of scope. This is of course very simple: sync() should be called by the destructor as well.

Now that we've considered the consequences of using an output buffer, we're almost ready to construct our derived class. We will add a couple of additional features, though.

First, we should allow the user of the class to specify the size of the output buffer.
Second, it should be possible to construct an object of our class before the file descriptor is actually known. Later, in section 20.3 we'll encounter a situation where this feature will be used.

In order to save some space, the successful operation of the various functions were not checked. In `real life' implementations these checks should of course not be omitted. Our class ofdnstreambuf has the following characteristics:

The class itself is derived from std::streambuf:

· class ofdnstreambuf: public std::streambuf

It uses three data members, keeping track of the size of the buffer, the file descriptor and the buffer itself:

· unsigned d_bufsize;

· int d_fd;

· char *d_buffer;

Its default constructor merely initializes the buffer to 0. Slightly more interesting is its constructor expecting a filedescriptor and a buffer size: it simply passes its arguments on to the class's open() member (see below). Here are the constructors:

· ofdnstreambuf()

· :

· d_bufsize(0),

· d_buffer(0)

· {}

· ofdnstreambuf(int fd, unsigned bufsize = 1)

· {

· open(fd, bufsize);

· }

The destructor calls the overridden function sync(), writing any characters stored in the output buffer to the device. If there's no buffer, the destructor needs to perform no actions:

· ~ofdnstreambuf()

· {

· if (d_buffer)

· {

· sync();

· delete[] d_buffer;

· }

The open() member initializes the buffer. Using setp(), the begin and end points of the buffer are set. This is used by the streambuf base class to initialize pbase() pptr() and epptr():

· void open(int fd, unsigned bufsize = 1)

· {

· d_fd = fd;

· d_bufsize = bufsize == 0 ? 1 : bufsize;

· d_buffer = new char[d_bufsize];

· setp(d_buffer, d_buffer + d_bufsize);

· }

The member sync() will write any not yet flushed characters in the buffer to the device. Next, the buffer is reinitialized using setp(). Note that sync() returns 0 after a successful flush operation:

· int sync()

· {

· if (pptr() > pbase())

· {

· write(d_fd, d_buffer, pptr() - pbase());

· setp(d_buffer, d_buffer + d_bufsize);

· }

· return 0;

· }

Finally, the member overflow() is overridden. Since this member is called from the streambuf base class when the buffer is full, sync() is called first to flush the filled up buffer to the device. As this recreates an empty buffer, the character c which could not be written to the buffer by the streambuf base class is now entered into the buffer using the member functions pptr() and pbump(). Notice that entering a character into the buffer is realized using available streambuf member functions, rather than doing it `by hand', which might invalidate streambuf's internal bookkeeping:

· int overflow(int c)

· {

· sync();

· if (c != EOF)

· {

· *pptr() = c;

· pbump(1);

· }

· return c;

· }

The member function implementations use low-level functions to operate on the file descriptors. So apart from streambuf the header file unistd.h must have been read by the compiler before the implementations of the member functions can be compiled.

Depending on the number of arguments, the following program uses the ofdstreambuf class to copy its standard input to file descriptor STDOUT_FILENO, which is the symbolic name of the file descriptor used for the standard output. Here is the program:

#include

#include "fdout.h"

using namespace std;

int main(int argc)

{

ofdnstreambuf fds(STDOUT_FILENO, 500);

ostream os(&fds);

switch (argc)

{

case 1:

os << "COPYING cin LINE BY LINE\n";

for (string s; getline(cin, s); )

os <<>

break;

case 2:

os << "COPYING cin BY EXTRACTING TO os.rdbuf()\n";

cin >> os.rdbuf(); // Alternatively, use: cin >> &fds;

break;

case 3:

os << "COPYING cin BY INSERTING cin.rdbuf() into os\n";

os <<>

break;

}

Memory Leaks

2008-12-04T20:54:00.000-08:00

Memory Leaks

Arrays always allocate memory statically, i.e. during compilation. As a result the desired generality may not be obtained in the program that uses an array. To avoid this it is common practice in software engineering to dynamically allocate memory from the heap for use by a program. In C and C++ once allocated it is not binding on part of the program to release this memory when it is no longer needed. When a program fails to do so, i.e. it does not return the allocated memory to the operating system, the memory chunk remains allocated but we are unable to access it. Losing memory in this manner is often known as a memory leak. In this article I would highlight the common causes of memory leakages while programming in C++. The discussion is independent of the operating system.

Cause no.1: Not using a delete at all:

Often one forgets to use the delete operator on memory that one has dynamically allocated with the new operator. However, once you grow knee high in C++ you would almost always avoid such memory leaks.

Cause no.2: Multiple exits in a function

Ideally there should be only one exit point in a function. It is however easier to preach this than practice it diligently. If you are using multiple returns in a function it might lead to an exit from the function before dynamically-allocated memory is freed. Here is a program to illustrate the point:

int func ( node *p )
{
if ( p == NULL )
return ( false ) ;

node *ptrtonode = new node ;

if ( ptrtonode == NULL )
return ( false ) ;

switch ( ptrtonode -> performance() )
{
case FIRST :
promote ( 1 ) ;
return ( true ) ;
case SECOND :
promote ( 2 ) ;
return ( true ) ;
default:
break;
}

delete ptrtonode ;

return ( false ) ;
}

As can be observed from the above code fragment, we have possibly saved a few clock cycles by not using a local Boolean variable to keep track of success or failure. We haven't used a local variable because whenever our code encountered an error it just returned to the calling function. However, if the performance is FIRST or SECOND the memory that portioned points to never gets deleted.

Cause No.3: Using several pointers with the same name

It's common knowledge that C++ allows and encourages a programmer to declare an automatic variable close to the point of usage. Sometimes this principle might land you into trouble. Using this rule we may declare an automatic variable that will point to a quantity of allocated memory right at the place of allocation. Suppose we have declared a pointer at the start of a function (in the traditional manner) and another pointer with the same name within an inner scope, at the point of instantiation. This is likely to cause a memory leak. Here is an example program:

void change shape ( int shape )
{
node *ptrtonode = NULL ;
if ( is valid ( shape ) != false )
{
node *ptrtonode = new node ;
ptrtonode->newshape ( shape ) ;
}
// which ptrtonode is this?
delete ptrtonode ;
}

In this code fragment two node pointers called ptrtonode are declared. The one inside the if statement points to an instance of a node object which is never deleted. The ptrtonode that does get deleted is null at the time of deletion. C++ guarantees that deleting a null pointer is harmless. Thus, a memory error detection tool may not flag this deletion as an error because it is a valid operation. A quick glance at the above function makes you think ptrtonode gets deleted, so there seems to be no problem. Whereas in actuality this might cause a serious memory leak.

Cause no. 4: Using delete on an Array

If we allocate an array with the array new operator (new[]) and then release the memory with the plain old delete operator it would result into a memory leak. For example:

char *ptr ;
ptr = new char[100];
delete ptr ; // NOT delete[] ptr ;

If you use the delete operator (and not the delete[] operator) to release an object that was allocated with new[], the resulting behavior is undefined. Even if you get away with this operation now it is likely to cause trouble later, or it may simply leak the memory.

Cause no. 5: Using careless Polymorphism

In C++ the destructors are not inherited. In C++, it is possible and in fact highly desirable to store the address of a derived-class object as a pointer to its base class. You get polymorphic behavior by referencing this derived class object through the base class pointer. The following program instantiates a derived-class object and stores the address as a pointer to its base class:

#include
class Base
{
public:
Base();
~Base();
};

class Derived : public Base
{
protected;
char *pBuf;
public:
Derived();
~Derived();
};

Base :: Base()
{
cout << "Base::Base()" << endl ;
}

Derived::Derived() : Base()
{
pBuf = new char [100];
cout << "Derived :: ~Derived()" << endl ;
}

Derived :: ~Derived()
{
delete[] pBuf ;
cout << "Derived :: ~Derived()" << endl ;
}

void main()
{
Base *pobject = new Derived() ;
delete pobject ;
}

On execution this program produces the following output:

Base::Base()
Derived::Derived()
Base::~Base()

Note that the destructor for the derived class did not get called. This would leak the buffer pBuf since it was allocated in the Derived constructor. To overcome this, simply declare the destructor of the Base class as a virtual function, as in:

class Base
{
public:
Base():
virtual ~Base();
} ;

The output of the program would now be:

Base::Base()
Derived::Derived()
Derived::~Derived()
Base::~Base()

Now the Derived class destructor is called, and Derived::pBuf is deleted.

C++ Templates

2008-12-04T20:52:00.001-08:00

Templates is an important addition in C++ when compared with C. Lot of readers have been sending queries about templates. I would try to explain a majority of them here in a question-answer form. The questions have been suitably modified to address a general audience.

What are templates?
Templates are a mechanism for generating functions and classes based on type parameters (templates are sometimes called "parameterised types"). By using templates, you can design a single class that operates on data of many types, instead of having to create a separate class for each type. For example, to create a type-safe function that returns the minimum of two parameters without using templates, you would have to write a set of overloaded functions like this:

// min for ints
int min( int a, int b )
{
return ( a < b ) ? a : b ;
}

// min for longs
long min( long a, long b )
{
return ( a < b ) ? a : b;
}

// min for chars
char min( char a, char b )
{
return ( a < b ) ? a : b;
}
// etc...

By using templates you can reduce this duplication to a single templated function as shown below:

template T min( T a,T b )
{
return ( a < b ) ? a : b;
}

Templates can significantly reduce source code size and increase code flexibility without reducing type safety.

What are function templates?
With function templates, you can specify a set of functions that are based on the same code, but act on different types or classes. For example:

template void MySwap( T& a, T& b)
{
T c( a );
a = b;
b = c;
}

This code defines a family of functions that swap their parameters. From this template you can generate functions that will swap not only int and long types, but also user-defined types. MySwap will even swap classes if the class's copy constructor and assignment operator are properly defined. In addition, the function template will prevent you from swapping objects of different types, since the compiler knows the types of the a and b parameters at compile time. Note that all of the template parameters inside the angle brackets must be used as parameters for the templated function. You call a templated functions as you would a non-templated function; no special syntax is needed. For example:

int i, j;
char k;
MySwap( i, j ); //OK
MySwap( i, k ); //Error, different types.

What do you mean by Function Template Instantiation?

When a templated function is first called for each type, the compiler creates an "instantiation", a specialized version of the templated function will be called every time the function is used for the type. If you have several identical instantiations, even in different modules, only one copy of the instantiation will end up in the executable. Standard type conversions are not applied to templated functions. Instead, the compiler first looks for an "exact match" for the parameters supplied. If this fails, it tries to create a new instantiation to create an "exact match". Finally, the compiler attempts to apply overloading resolution to find a match for the parameters. if this fails, the compiler generates an error. What is a function template override? With a templated function, you can define special behavior for a specific type by providing a non-templated function for that type. For example:

void MySwap( double a, double b );

This declaration enables you to define a different function for double variables. Like other non-templated functions, Standard type conversions (such as promoting a variable of type float to double) are applied.

What are Class Templates?

You can use class templates to create a family of classes that operate on a type. For example:

template class ex
{
public:
ex ( void ) ;
~ex( void ) ;
int setdata( T a, int b ) ;
private:
T Tarray[i] ;
int arraysize ;
} ;

In this example, the templated class uses two parameters, a type T and an int i. The T parameter can be passed any type, including structures and classes. The i parameter has to be passed an integer constant. Since i is a constant defined at compile time, you can define a member array of size i using a standard automatic array declaration. Unlike function templates, you do not use all template parameters in the definition of a templated class.

How do you define member functions of a template class?

Members of template class are defined slightly differently than those of non-templated class. Continuing the preceding example:

template
int ex<>::setdata( T a, int b )
{
if( ( b >= 0 ) && (b < i ) )
{
Tarray[b++] = a ;
return sizeof( a ) ;
}
else
return -1 ;
}

Constructors and Destructors

Although constructors and destructors reference the name of the templated class twice, the template parameters should be referenced only once in the fully specified name.

template
TempClass<>::TempClass( void )
{
TRACE( "TempClass created. \n" ) ;
}

template
TempClass<>::~TempClass( void )
{
TRACE( "TempClass destroyed. \n" ) ;
}

Class Template Instantiation

Unlike function templates, when instantiating a class template, you must explicitly instantiate the class by giving the parameters for the templated class. To create an instance of TempClass:

TempClass<> test1 ; // OK
TempClass<> test2 ; // Error, second parameter
// must be constant.

No code is generated for a templated class ( or function ) until it is instantiated. Moreover, member functions are instantiated only if they are called. This can cause problems if you are building a library with templates for other users.

Angle Bracket Placement

Bad placement of angle brackets ( <> ) causes many template syntax errors. Make sure that you use proper spacing and parenthesis to distinguish angle brackets from operators such as >> and ->. For example:

TempClass<> b ? a : b > test1 ;

should be rewritten as

TempClass<> b ? a : b ) > test1 ;

Similarly, pay extra attention when using macros that use angle brackets as template arguments.

When Should You Use Templates ?

Templates are often used to :
* Create a type-safe collection class ( for example, a stack ) that can operate on data of any type.
* Add extra type checking for functions that would otherwise take void pointers.
* Encapsulate groups of operator overrides to modify type behavior ( such as smart pointers ) .
Most of these uses can be implemented without templates offer several advantages:
* Templates are easier to write. You create only one generic version of your class or function instead of manually creating specializations.
* Templates can be easier to understand, since they can provide a straightforward way of abstracting type information.
* Templates are type safe. Since the types that templates act upon are known at compile-time, the compiler can perform type checking before errors occur.

Templates vs. Macros

In many ways, templates work like preprocessor macros, replacing the templated variable with the given type. However, there are many differences between a macro like this:

# define min(i,j) ((i) < (j) ? (i) : (j))

and template:

template T min (T i, T j) { return (i
Here are some problems with the macro :
* There is no way for the compiler to verify that the macro parameter are of compatible types. The macro is expanded without any special; type checking.
* The i and j parameter are evaluated twice . For example, if either parameter has a post incremented variable, the incremented is performed two times.
* Since macros are expanded by the preprocessor, compiler error messages will refer to the expanded macro, rather than the macro definition itself. Also the macro will show up in expanded form during debugging.

Templates vs. void Pointers

Many functions that are now implemented with void pointers can be implemented with templates. Void pointers are often used to allow functions to operate on data of an unknown type. When using void pointers, the compiler cannot distinguish types, so it cannot perform type checking or type-specific behavior such as using type-specific operator overloading, or constructors and destructors . With templates, you can create functions and classes that operate on typed data. The type looks abstracted in the template definition. However, at compile-time the compiler creates a separate version of the function for each specified type. This enables the compiler to treat templated classes and function as if they acted on specific types. Templates can also improve coding clarity, since you don't need to create special cases for complex types such as structures.

Collection Classes

Templates are a good way of implementing collection classes. Version 3.0 of the Microsoft Foundation Classes uses templates to implement six new collection classes: CArray, CMap, CTypedPtrArray, CTypedPtrList, and CTypedPtrMap. For information on using and customizing these classes, see the "collections" articles in Programming with the Microsoft Foundation Class Library. The My stack collection is a simple implementation of a stack. The two template parameter ,T and i, specify the type of elements in the stack and the maximum number of that item in the stack. The push and pop member functions add and remove items in the stack, with the stack growing from the bottoms of the stack.

templates class My stack
{
T stackBuffer[i];
int cItems;
public:
void Mystack(void):cItems(i) {};
void push ( const T items ) ;
T pop ( void );
};
template void My stack<>::push (const T items)
{
if (cItems >0)
stackbuffer[--cItems] = items;
else
throw " stack overflow error .";
return;
}

template T My stack::pop (void)
{
if(cItems return stackBuffer[cItems++]
else
throw "stack underflow error .";
}

Smart Pointers

C++ allows you to create "smart pointer" classes that encapsulate pointer and override pointer operators to add new functionally to pointer of almost any type. The following code outlines a simple references count garbage collector. The template class Ptr implemented a garbage collecting pointer to any class derived from Refcount.

class Refcount
{
int crefs;
public:
Refcount (void){crefs =0;}
void upcount(void){ ++crefs;}
void downcount(void){if(--crefs ==0)delete this ;}
};
class Sample : public Refcount
{
public :
void dosomething(void){ TRACE(did somethiing\n");}
};
template class Ptr
{
T* p;
public :
Ptr(T* P_): p(p_){ p->upcount();}
~Ptr(void){ p->downcount();}
operator T*(void){ return p;}
T& oprator* (void){return *p}
T* operator->(void){ return p;}
Ptr& operator =(t*p_)
{
p->upcount(); p=p_ ; p->downcount();return *this;
}
};

int main()
{
Ptr p =new Samples; // samples #1
Ptr p2 = new Samples;// samples #2
p=p2; // #1 has 0 refs, so it is destroyed ; #2 has two refs
p->doSomething();
return 0;
// As p2 and p go out of scope, their destructors call
// downcount. The cref varaible of #2 goes to 0,so #2 is
//destroyed
}

Classes Refcount and Ptr> together provide a simple garbage collection solution for any class that can afford the int per instance overhead to inherit from Refcount. Note that primary benefit of using a parametric class like Ptr instead of a more generic class like Ptr is the former is complete type-safe. The preceding code ensures that a Ptr can be used almost anywhere a T* is used; in contrast, a generic Ptr would only provide implicit conversions to void*. For example, if this class is used to create and manipulate garbage collected files, symbols, strings, and so forth. From the class template Ptr, the compiler will create template classes Ptr, Ptr, Ptr, and so on, and their member functions: Ptr::~Ptr( ), Ptr:: operator File*( ), Ptr::~Ptr( ), Ptr::operator String*( ), and so on.

What is a copy constructor ? What is the difference between copy constructor and overloaded assignment operator ?

2008-11-23T00:38:00.000-08:00

What is a copy constructor ?What is the need for it ? What is the Shallow and deep copy ? When it gets called ? Write the signature ? What is the difference between copy constructor and overloaded assignment operator ? Answers.....