C++ TUTORIALS

C++ STL UNARY PREDICATE FUNCTIONS

noreply@blogger.com (Ron Tinnel) — Sat, 24 Sep 2011 21:32:00 -0400

C++ STL UNARY PREDICATE FUNCTIONS TUTORIAL

REVISED: Sunday, March 3, 2013

CONTENTS:
I. INTRODUCTION
II. PREDICATE FUNCTIONS
III. WRITING UNARY PREDICATES

YOU WILL LEARN HOW TO:
1. Write STL unary predicates.
2. Use the STL unary predicate functions with arrays.
3. Use the STL unary predicate functions with lists.
4. Use the STL unary predicate functions with vectors.

• I. INTRODUCTION

Welcome to the “C++ STL Unary Predicate Function Tutorial.”

• II. PREDICATE FUNCTIONS

Predicate functions test the truth or falsity of conditions; for example, an isEmpty function or an isFull function. A binary predicate function takes two arguments, performs a comparison using those two arguments and returns a bool value indicating the result. A unary predicate function takes a single value argument, performs a comparison using that argument and returns a bool value indicating that result.

A. UNARY PREDICATE FUNCTIONS

Examples of the unary predicate functions are: replace_if, remove_if, partition, stable_partition, replace_copy_if, remove_copy_if, count_if, and find_if.

In the STL, instead of seeing unary predicate function you will normally just see the word predicate.

For discussion purposes, lets take a look at the STL count_if( ) function.

The count_if( ) function has three parameters. The first parameter is the starting point. The second parameter is the ending point. The third parameter is the unary predicate which returns the condition you want for inclusion in the count returned by the count_if( ) function.

count_if( ) returns the total of the number of elements that match a unary predicate condition between the starting point and the ending point in a series of elements.

1. ARRAY EXAMPLE

The syntax for instantiating an array object is as follows:

type arrayName [arrayElements];

a. A one-dimensional array name by itself without the elements enclosed by the square brackets is automatically converted to a pointer to the address of the first element of the array. Therefore, the array name A, in the attached array example program, is used for the first parameter.

b. The amount of memory required to store each element of an array is determined by its type. And, all the elements of the array are stored in a contiguous block of memory. Therefore, the sizeof operator is very useful when working with an array. In the const int N = (sizeof(A) / sizeof(A[0])); statement of the following array example program; sizeof( ) divides the number of bytes occupied by the whole A[ ] array by the number of bytes occupied by the first element of the A[ ] array. Because each element in the array occupies the same amount of memory, the result is the number of elements in the A[ ] array. After being computed, the number of elements in the A[ ] array is assigned to the variable N. Using pointer arithmetic, A + N is used for the second parameter.

c. The third parameter is the unary predicate which returns the condition you want for inclusion in the count returned by the count_if( ) function. The attached example program unary predicate function name is isMoreThan30.

The array example program is as follows:

//***********************************
//C++ STL UNARY PREDICATE
//FUNCTIONS TUTORIAL
//Array Example:
//***********************************
#ifndef CALC_ERROR_H
#define CALC_ERROR_H
#include <algorithm>
#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
#endif
//CALC_ERROR_H

void ClearScreen( );
//Clears the screen.
void Pause( );
//Waits for user response.
bool evenlyDivisibleByTwo(int i); //Returns true if number
//is an even number.

//***********************************
//Clear Screen.
//***********************************
void ClearScreen( )
{
system( "CLS" );
cout << endl << endl << endl;
}

//***********************************
//Pause.
//***********************************
void Pause( )
{
cout << endl << endl << endl;
cout << " ";
system( "PAUSE" );
}

//***********************************
//Unary Predicate Function:
//Returns true if number is more than
//30.
//***********************************
bool isMoreThan30( int value )
{
return value >30;
}

//***********************************
// MAIN() FUNCTION.
//***********************************
int main(int argc, char* argv[ ])
{
ClearScreen( );
int A[ ] = { 9, 12, 32, 18, 4, 96, 5, 42, 33, 10 };
const int N = (sizeof(A) / sizeof(A[0]));
cout << endl << endl;

cout << " The " << count_if(A, (A + N), isMoreThan30);

cout << " numbers more than 30 are: ";
for( int i = 0; i < N; i++ )
{
if (isMoreThan30( A[ i ] ))
{
cout << A[ i ] << " ";
}
}
Pause( );
return EXIT_SUCCESS;
}

2. LIST EXAMPLE:

The syntax for instantiating a list object is as follows:

list <type> objectName;

list is a C++ keyword. The angle brackets contain the word type <type> which is a placeholder for the type of the list you are instantiating. objectName is the name of the list object you are instantiating.

When working with a list the count_if( ) function’s three parameters are as follows:

a. objectName.begin( ) sets the list element starting point.

begin( ) is a function that automatically moves the pointer to the first element of the list.

b. objectName.end( ) sets the list element ending point.

end( ) is a function that automatically works with the begin( ) function to establish a range of list elements which will be tested for the condition of the unary predicate. In this case the range is from the first element of the list to the last element of the list.

c. Unary Predicate

The unary predicate is established by the programmer by writing a Boolean function which returns the appropriate condition for the count_if( ) function. The attached list example program unary predicate function name is isDivisibleByThree.

The list example program is as follows:

//**********************************
//C++ STL UNARY PREDICATE
//FUNCTIONS TUTORIAL
//List Example:
//**********************************
#ifndef CALC_ERROR_H
#define CALC_ERROR_H
#include <algorithm>
#include <cstdlib>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <sstream>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
#endif
//CALC_ERROR_H

void ClearScreen( );
//Clears the screen.
void Pause( );
//Waits for user response.
bool evenlyDivisibleByTwo(int i); //Returns true if number is
//an even number.

//**********************************
//Clear Screen.
//**********************************
void ClearScreen( )
{
system( "CLS" );
cout << endl << endl << endl;
}

//**********************************
//Pause.
//**********************************
void Pause( )
{
cout << endl << endl << endl;
cout << " ";
system( "PAUSE" );
}

//**********************************
//Unary Predicate Function:
//Returns true if number is more than
//30.
//**********************************
//bool isMoreThan30( int value )
//{
// return value > 30;
//}

//**********************************
//Unary Predicate Function:
//Returns true if number is
//divisible by 3.
//**********************************
bool isDivisibleBy3(int i)
{
if((i%3) == 0) return true;

return false;
}

//**********************************
// MAIN() FUNCTION.
//**********************************
int main(int argc, char* argv[ ])
{
ClearScreen( );

//Instantiate object myList.
list<int> myList;

//Insert list elements.
for ( int i=6; i<=20; ++i )
{
myList.push_back( i );
if ( isDivisibleBy3( i ) )
{
cout << " " << i;
}
}

//Instantiate iterator.
list<int>::iterator myIt;

cout << " are the " << count_if(myList.begin( ), myList.end( ), isDivisibleBy3);
cout << " numbers divisible by 3. ";

Pause( );
return EXIT_SUCCESS;
}

3. VECTOR EXAMPLE

The syntax for instantiating a vector object is as follows:

vector <type> objectName;

vector is a C++ keyword. The angle brackets contain the word type <type> which is a placeholder for the type of the vector you are instantiating. objectName is the name of the vector object you are instantiating.

When working with a vector the count_if( ) function’s three parameters are as follows:

a. objectName.begin( ) sets the vector element starting point.

begin( ) is a function that automatically moves the pointer to the first element of the vector.

b. objectName.end( ) sets the vector element ending point.

end( ) is a function that automatically works with the begin( ) function to establish a range of vector elements which will be tested for the condition of the unary predicate. In this case the range is from the first element of the vector to the last element of the vector.

c. Unary Predicate

The unary predicate is established by the programmer by writing a Boolean function which returns the appropriate condition for the count_if( ) function. The attached vector example program unary predicate function name is evenlyDivisibleByTwo.

The vector example program is as follows:

//**********************************
//C++ STL PREDICATE
//FUNCTIONS TUTORIAL
//Vector Example:
//**********************************
#ifndef CALC_ERROR_H
#define CALC_ERROR_H
#include <algorithm>
#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
#endif
//CALC_ERROR_H

void ClearScreen( );
//Clears the screen.
void Pause( );
//Waits for user response.
bool evenlyDivisibleByTwo(int i); //Returns true if number
//is an even number.

//**********************************
//Clear Screen.
//**********************************
void ClearScreen( )
{
system( "CLS" );
cout << endl << endl << endl;
}

//**********************************
//Pause.
//**********************************
void Pause( )
{
cout << endl << endl << endl;
cout << " ";
system( "PAUSE" );
}

//**********************************
//Unary Predicate Function:
//Returns true if number is an even
//number.
//**********************************
bool evenlyDivisibleByTwo( int i )
{
return !( i%2 );
}

//**********************************
// MAIN() FUNCTION.
//**********************************
int main(int argc, char* argv[ ])
{
ClearScreen( );

vector< int > VO;

int i;

for( i = 1; i < 40; i++ )
VO.push_back( i );

cout << " The even numbers are: ";
for(i = 0; i < VO.size( ); i++)
{
if (evenlyDivisibleByTwo( VO[ i ] ))
{
cout << VO[ i ] << " ";
}
}
cout << endl << endl;

i = count_if(VO.begin( ), VO.end( ), evenlyDivisibleByTwo);
cout << " " << i << " TOTAL" << endl;

Pause( );

return EXIT_SUCCESS;
}

• III. WRITING UNARY PREDICATES

The following must be taken into consideration when writing predicates:

A. A unary predicate is called like a function; therefore, a unary predicate must be callable.

B. A unary predicate must accept one argument and return a value that is convertible to Boolean. One argument is supplied when the predicate is called. The return value is used as a conditional expression and must be convertible to type bool.

C. The predicate must not modify its argument. A unary predicate must not modify the elements in the input sequence that it receives as an argument. The unary predicate can inspect the sequence elements, but it must not modify them.

D. Unary predicates logic must not be dependent on the order in which sequence elements are supplied to it.

YOU HAVE LEARNED HOW TO:
1. Write STL unary predicates.
2. Use the STL unary predicate functions with arrays.
3. Use the STL unary predicate functions with lists.
4. Use the STL unary predicate functions with vectors.

Elcric Otto Circle

-->

How to Link to My Home Page

It will appear on your website as:

"Link to: ELCRIC OTTO CIRCLE's Home Page"

C++ FILE PROCESSING...

noreply@blogger.com (Ron Tinnel) — Sat, 24 Sep 2011 21:06:00 -0400

C++ FILE PROCESSING TUTORIAL

REVISED: Sunday, March 3, 2013

CONTENTS:
• I. ASSUMPTIONS
• II. INTRODUCTION
• III. VOCABULARY
• IV. CREATING A SEQUENTIAL FILE

YOU WILL LEARN:
1. File processing vocabulary.
2. How to create a sequential file.

• I. ASSUMPTIONS

I assume you have a C++ compiler and you want to learn about C++ file processing.

• II. INTRODUCTION

Welcome to the “C++ File Processing Tutorial.”

Please copy and paste the two following example programs into a file your compiler can read. Then build, compile, and debug the two example programs. Following along, back and forth, between the tutorial and your copy of the two example programs will help you understand the example program's functionality.

//**********************************
//C++ Beginner File Processing
//Tutorial Sequential File
//**********************************
#ifndef CALC_ERROR_H
#define CALC_ERROR_H
#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <string>
using namespace std;
using std::cerr;
using std::cin;
using std::cout;
using std::endl;
using std::fixed;
using std::exit;
using std::ifstream;
using std::ios;
using std::left;
using std::right;
using std::ofstream;
using std::setw;
using std::showpoint;
using std::setprecision;
using std::string;

#endif //CALC_ERROR_H

class CAccountsPayable
{
public:

CAccountsPayable();
void m_CreateSequentialFile();
void m_ReadSequentialFile();
~CAccountsPayable();
private:

int account;
char lastName[ 15 ];
char firstName[ 10 ];
double balance;

};

CAccountsPayable::CAccountsPayable() //Constructor.
{

}

//**********************************
//Creates a sequential file.
//**********************************
void CAccountsPayable::m_CreateSequentialFile()
{
ofstream outCustomerFile("CustomerFile.dat", ios::out);
//File created for output.
//Two arguments passed to
//constructor: filename, and
//file open mode.
//ios::out output mode to truncate
//an existing file and output
//new data to the file.
//ios::out creates a new file
//if the file does not already exist.
//By default ofstream oubjects
//are opened for output; therefore,
//ios::out was not needed.
//ios::app append mode
//to append data to the end
//of an existing file.

int account = 0;
char lastName[ 15 ] = {" "};
char firstName[ 10 ] = {" "};
double balance = 0.0;
int choice = 0;
bool exitt = false;

if (outCustomerFile.is_open())
//Checks to see if file is open.
{
system( "CLS" );
cout << endl << endl << endl;
cout << " C++ Beginner File Processing Tutorial" << endl << endl;
cout << " Sequential File" << endl << endl;

do
{
cout << endl << endl << endl;
cout << " Please enter customer account number." << endl << endl;
cout << " Any number from 1 to 100, for example, 1 " << endl << endl;
cout << " and then press Enter => ";
cin >> account;
cout << endl << endl << endl;
cout << " You entered " << account;
cout << endl << endl << endl;
cout << " ";
system ("PAUSE");

system( "CLS" );
cout << endl << endl << endl;
cout << " Please enter customer last name." << endl << endl;
cout << " Maximum 15 characters, for example Jones" << endl << endl;
cout << " and then press Enter => ";
cin >> lastName;
cout << endl << endl << endl;
cout << " You entered " << lastName;
cout << endl << endl << endl;
cout << " ";
system ("PAUSE");

system( "CLS" );
cout << endl << endl << endl;
cout << " Please enter customer first name." << endl << endl;
cout << " Maximum 10 characters, for example Roy" << endl << endl;
cout << " and then press Enter => ";
cin >> firstName;
cout << endl << endl << endl;
cout << " You entered " << firstName;
cout << endl << endl << endl;
cout << " ";
system ("PAUSE");

system( "CLS" );
cout << endl << endl << endl;
cout << " Please enter customer account balance." << endl << endl;
cout << " for example, 1000 " << endl << endl;
cout << " and then press Enter => ";
cin >> balance;
cout << endl << endl << endl;
cout << " You entered " << balance;
cout << endl << endl << endl;
cout << " ";
system ("PAUSE");

outCustomerFile << account << " " << lastName << " " << firstName << " " << balance << endl;
//One record of four fields each
//separated by a blank space.

system( "CLS" );
cout << endl << endl << endl;

cout << " Type the number 1 and press return ";
cout << "to enter another record. " << endl << endl;
cout << " Type 0 and press return to exit. ==> ";
cin >> choice;
if ( choice == 0 )
{
break;
}
if ( choice == 1 )
exitt = false;
else
{
exitt = true;
}
}while( exitt == false );

outCustomerFile.close();
//Closes file.
}
else
{
if(!outCustomerFile)
{
system( "CLS" );
cout << endl << endl << endl;
cerr << " Unable to open file.";
cout << endl << endl << endl;
cout << " ";
system ("PAUSE");
exit(1);
//Argument 0 is a normal exit,
//any other value is an error exit.
}
}
}

//**********************************
//Reads a sequential file.
//**********************************
void CAccountsPayable::m_ReadSequentialFile( )
{
ifstream inCustomerFile("CustomerFile.dat", ios::in);
//File created for input.
//Two arguments passed to
//constructor: filename, and
//file input mode.
//ios::in input mode to open an
//existing file for input from the
//file into the program.
//ios::in results in an error message
//if the file does not already exist.

int account = 0;
char lastName[15] = {" "};
char firstName[10] = {" "};
double balance = 0.0;

if (inCustomerFile.is_open( ))
//Checks to see if file is open.
{
while( inCustomerFile >> account >> lastName >> firstName >> balance )
{
system ("CLS");
cout << endl << endl << endl;
cout << " Account Number: " << account << endl << endl;
cout << " Last Name: " << lastName << endl << endl;
cout << " First Name: " << firstName << endl << endl;
cout << " Account Balance: " << balance << endl << endl; //One record.

cout << endl << endl << endl;
cout << " ";
system ("PAUSE");
}

inCustomerFile.close( );
//Closes file.
}
else
{
if(!inCustomerFile)
{
system( "CLS" );
cout << endl << endl << endl;
cerr << " Unable to open file.";
cout << endl << endl << endl;
cout << " ";
system ("PAUSE");
exit(1);
//Argument 0 is a normal exit,
//any other value is an error exit.
}
}
}

CAccountsPayable::~CAccountsPayable()
//Destructor.
{

}

//**********************************
// MAIN( ) FUNCTION.
//**********************************
int main(int argc, char* argv[ ])
{
int choice = 0;
bool exit = false;

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

CAccountsPayable OPencil;

do
{
OPencil.m_CreateSequentialFile( );
OPencil.m_ReadSequentialFile( );

//**********************************
system( "CLS" );
cout << endl << endl << endl;
cout << " Type the number 1 and press return ";
cout << "to run the program again. " << endl << endl;
cout << " Type 0 and press return to exit. ==> ";
cin >> choice;
if ( choice == 0 )
{
EXIT_SUCCESS;
}
if ( choice == 1 )
exit = false;
else
{
exit = true;
}
}while( exit == false );

OPencil.~CAccountsPayable();

return EXIT_SUCCESS;
}

//**********************************
//C++ File Processing Tutorial
//Random Access File
//**********************************
#ifndef CALC_ERROR_H
#define CALC_ERROR_H
#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <string>
using namespace std;
using std::cerr;
using std::cin;
using std::cout;
using std::endl;
using std::fixed;
using std::exit;
using std::ifstream;
using std::ios;
using std::left;
using std::right;
using std::ofstream;
using std::ostream;
using std::setw;
using std::showpoint;
using std::setprecision;
using std::string;

#endif //CALC_ERROR_H

class CAccountsPayable
{
public:

//Constructor.
CAccountsPayable( int = 0, string = "", string = "", double = 0.0 );

//Accessor function for account number.
void m_SetAccountNumber( int );
int m_GetAccountNumber( ) const;

//Accessor function for last name.
void m_SetLastName( string );
string m_GetLastName( ) const;

//Accessor function for first name.
void m_SetFirstName( string );
string m_GetFirstName( ) const;

//Accessor function for balance.
void m_SetBalance( double );
double m_GetBalance( ) const;

//Destructor.
~CAccountsPayable( );

private:

int accountNumber;
char lastName[ 15 ];
char firstName[ 10 ];
double balance;
};

//**********************************
//Constructor
//**********************************
CAccountsPayable::CAccountsPayable(int accountNumberValue,
string lastNameValue, string firstNameValue, double balanceValue )
{
m_SetAccountNumber( accountNumberValue );
m_SetLastName( lastNameValue );
m_SetFirstName( firstNameValue );
m_SetBalance( balanceValue );
}

//**********************************
//Get account number value.
//**********************************
int CAccountsPayable::m_GetAccountNumber( ) const
{
return accountNumber;
}

//**********************************
//Set account number value.
//**********************************
void CAccountsPayable::m_SetAccountNumber( int accountNumberValue )
{
accountNumber = accountNumberValue;
}

//**********************************
//Get last name value.
//**********************************
string CAccountsPayable::m_GetLastName( ) const
{
return lastName;
}

//**********************************
//Set last name value.
//**********************************
void CAccountsPayable::m_SetLastName( string lastNameString )
{
const char *lastNameValue = lastNameString.data( );
int length = lastNameString.size( );
length = ( length < 15 ? length : 14 );
strncpy_s( lastName, lastNameValue, length );
lastName[ length ] = '\0';
}

//**********************************
//Get first name value.
//**********************************
string CAccountsPayable::m_GetFirstName( ) const
{
return firstName;
}

//**********************************
//Set first name value.
//**********************************
void CAccountsPayable::m_SetFirstName( string firstNameString )
{
const char *firstNameValue = firstNameString.data( );
int length = firstNameString.size( );
length = ( length < 10 ? length : 9 );
strncpy_s( firstName, firstNameValue, length );
firstName[ length ] = '\0';
}

//**********************************
//Get balance value.
//**********************************
double CAccountsPayable::m_GetBalance( ) const
{
return balance;
}

//**********************************
//Set balance value.
//**********************************
void CAccountsPayable::m_SetBalance( double balanceValue )
{
balance = balanceValue;
}

//**********************************
//Destructor
//**********************************
CAccountsPayable::~CAccountsPayable( )
{

}

//**********************************
// MAIN() FUNCTION.
//**********************************
int main(int argc, char* argv[ ])
{
int choice = 0;
bool exitt = false;
//**********************************

do
{
system("CLS");
cout << endl << endl << endl;
cout << " C++ Beginner File Processing Tutorial " << endl << endl;
cout << " --------------------------------------- " << endl << endl;
cout << " 0 Quit, exits program. " << endl << endl;
cout << " 1 Create Random Access File: " << endl;
cout << " Writes Fixed Length Records To File " << endl << endl;
cout << " 2 Write To Random Access File " << endl << endl;
cout << " 3 Read Random Access File Sequentially " << endl << endl << endl;

cout << endl << endl;
cout << " Please type a number from 0 to 3 " << endl << endl;
cout << " then press Enter ==> ";

cin >> choice;

switch(choice)
//start switch
{
case (0):
exitt = true;
return EXIT_SUCCESS;
break;

case (1):
//**********************************
//Writes fixed length records to
//random access file. //**********************************
{
ofstream outAccountsPayable( "AccountsPayable.dat",
ios::out | ios::binary );

if ( !outAccountsPayable )
{
system("CLS");
cout << endl << endl << endl;
cerr << " File could not be opened." << endl;
cout << endl << endl << endl;
cout << " ";
system("PAUSE");
exit( 1 );

//Instantiates object
//OBlankAccountsPayable of type
//CAccountsPayable.
CAccountsPayable OBlankAccountsPayable;

for ( int i = 0; i < 100; i++ )
{
outAccountsPayable.write( reinterpret_cast
< const char * > ( &OBlankAccountsPayable ),
sizeof ( CAccountsPayable ) );
}
}
system("CLS");
cout << endl << endl << endl;
cout << " Congratulations you successfully created a random access file! " << endl << endl << endl;
cout << endl << endl << endl;
cout << " ";
system ("PAUSE");

}

//**********************************
break;

case (2):

//**********************************
//Writes to the random access file. //**********************************
{
int accountNumber;
char lastName[ 15 ];
char firstName[ 10 ];
double balance;

fstream outAccountsPayable( "AccountsPayable.dat",
ios::in | ios::out |ios::binary );

if ( !outAccountsPayable )
{
system("CLS");
cout << endl << endl << endl;
cerr << " File could not be opened." << endl;
cout << endl << endl << endl;
cout << " ";
system("PAUSE");
exit( 1 );
}

system("CLS");
cout << endl << endl << endl;
cout << " Please enter customer account number." << endl << endl;
cout << " Enter a number from 1 to 100 " << endl << endl;
cout << " then press Enter => ";

//Instantiates object OCustomer
//of type CAccountsPayable.
CAccountsPayable OCustomer;

cin >> accountNumber;
cout << endl << endl << endl;
cout << " You entered " << accountNumber;
cout << endl << endl << endl;
cout << " ";
system ("PAUSE");

if( accountNumber > 0 && accountNumber <= 100 )
{
system( "CLS" );
cout << endl << endl << endl;
cout << " Please enter customer last name." << endl << endl;
cout << " Maximum 15 characters, for example Jones" << endl << endl;
cout << " and then press Enter => ";
cin >> setw( 15 ) >> lastName;
cout << endl << endl << endl;
cout << " You entered " << lastName;
cout << endl << endl << endl;
cout << " ";
system ("PAUSE");

system( "CLS" );
cout << endl << endl << endl;
cout << " Please enter customer first name." << endl << endl;
cout << " Maximum 10 characters, for example Roy" << endl << endl;
cout << " and then press Enter => ";
cin >> setw( 10 ) >> firstName;
cout << endl << endl << endl;
cout << " You entered " << firstName;
cout << endl << endl << endl;
cout << " ";
system ("PAUSE");

system( "CLS" );
cout << endl << endl << endl;
cout << " Please enter customer account balance." << endl << endl;
cout << " for example, 1000 " << endl << endl;
cout << " and then press Enter => ";
cin >> balance;
cout << endl << endl << endl;
cout << " You entered " << balance;
cout << endl << endl << endl;
cout << " ";
system ("PAUSE");
OCustomer.m_SetAccountNumber( accountNumber );
OCustomer.m_SetLastName( lastName );
OCustomer.m_SetFirstName( firstName );
OCustomer.m_SetBalance( balance );

outAccountsPayable.seekp( ( OCustomer.m_GetAccountNumber( ) - 1 ) *
sizeof( CAccountsPayable ) );

outAccountsPayable.write( reinterpret_cast< const char * > ( &OCustomer ),
sizeof( CAccountsPayable ) );
}
}
//**********************************
break;

case (3):
//**********************************
//Read random access file sequentially.
//**********************************
{
ifstream inAccountsPayable( "AccountsPayable.dat",
ios::in | ios::binary );

if ( !inAccountsPayable )
{
system("CLS");
cout << endl << endl << endl;
cerr << " File could not be opened." << endl;
cout << endl << endl << endl;
cout << " ";
system("PAUSE");
exit( 1 );
}

cout << left << setw( 10 ) << "Account"
<< setw ( 16 ) << "Last Name" << left
<< setw ( 11 ) << "First Name"
<< setw ( 10 ) << right << "Balance" << endl;

//Instantiates object OCustomer
//of type CAccountsPayable.
CAccountsPayable OCustomer;

inAccountsPayable.read( reinterpret_cast< char * >
( &OCustomer ), sizeof( CAccountsPayable ) );

while ( inAccountsPayable && !inAccountsPayable.eof( ) )
{
if ( OCustomer.m_GetAccountNumber( ) != 0 )
{
system("CLS");
cout << endl << endl << endl;
cout << " ";

cout << left << setw( 10 ) << OCustomer.m_GetAccountNumber( )
<< setw ( 16 ) << OCustomer.m_GetLastName( ) << left
<< setw ( 11 ) << OCustomer.m_GetFirstName( )
<< setw ( 10 ) << setprecision( 2 ) << right << fixed
<< showpoint << OCustomer.m_GetBalance( ) << endl;

cout << endl << endl << endl;
cout << " ";
system("PAUSE");
}

inAccountsPayable.read( reinterpret_cast< char * >
( &OCustomer ), sizeof( CAccountsPayable ) );
}

}

//**********************************
break;

default:
cout << endl << endl << endl;
cout << "Switch default error message! ";
cout << endl << endl << endl;
system("PAUSE");
break;
}

}while( exitt == false );

return EXIT_SUCCESS;
}

• III. VOCABULARY

A. What is a bit?

A bit is a binary digit that can assume one of two values, 0 or 1. A bit is the smallest data item supported by computers.

B. What is a byte?

A byte is eight bits.

C. What is a character?

Digits, letters, and special symbols are referred to as characters.

D. What is a field?

A field is composed of characters that convey meaning.

E. What is a record?

A record is represented as a class in C++ and is composed of fields called data members.

F. What is a file?

Files you create with your editor are called source files. Most C++ compilers do not care what extension you give your source file, .cpp is normally the default. After your source file is compiled an object file is produced with an .obj or .o extension, C++ executable .exe extension programs are created by linking one or more object files with one or more libraries. Libraries are linkable files supplied with your compiler.

The files we will be discussing in this tutorial are the text files and binary files that store data which can be retrieved for processing when needed.

A storage file is a group of related records. C++ views each file as a sequence of bytes. When a file is opened an object is created and a stream is associated with that object. If the file can support position requests, opening the file also initializes the file position indicator to the start of the file. To perform file processing in C++, header files <iostream> and <fstream> must be included to provide communications between a program and a file or device.

Standard input, standard output, and standard error output are three files that are connected to the console and opened automatically when a program is started. The file pointers stdin, stdout, and stderr are also automatically provided for these three files respectively.

G. What is a record key?

A record key uniquely identifies a record.

H. What is a database?

A group of related files are stored in a database.

I. What is a Database Management System (DBMS)?

A DBMS is a collection of programs designed to create and manage a database.

• IV. CREATING A SEQUENTIAL FILE

Step 1 Create A Stream:

Before you can use the member functions of a class in your program you have to create a stream by instantiating or declaring an object of that class in your program. The class for output is ofstream. You can use any object name you want to use.

The syntax for instantiating an object of the ofstream class is as follows:

ofstream object_name;

Step 2 Associate Or Link That Object With A File

After you create a stream by instantiating an object of the class in your program you have to associate or link that object with a file. You can use the open( ) function to associate the instantiated object with a file.

The complete detailed syntax for the prototype of an output file is as follows:

void ofstream::open(const char *filename, ios::openmode mode = ios::out | ios::trunc);

When the ofstream object is instantiated and associated with a file the ofstream object’s constructor opens the file.

After the stream object is associated with a file, the file can be used the same as any other stream object.

YOU HAVE LEARNED:
1. File processing vocabulary.
2. How to create a sequential file.

Elcric Otto Circle

-->

-->

-->

How to Link to My Home Page

It will appear on your website as:

"Link to: ELCRIC OTTO CIRCLE's Home Page"

C++ STL STACK CLASS

noreply@blogger.com (Ron Tinnel) — Sat, 24 Sep 2011 20:32:00 -0400

REVISED: Sunday, March 3, 2013

CONTENTS:
• I. ASSUMPTIONS
• II. INTRODUCTION
• III. VOCABULARY
• IV. CLASS TEMPLATE STACK<T>
• V. MEMBER FUNCTIONS
• VI. CONSTRUCTOR

YOU WILL LEARN:
1. Stack class template vocabulary.
2. How to declare and use a stack class template constructor.
3. How to instantiate objects of type stack.
4. The stack class member functions and how to use them.

• I. ASSUMPTIONS

I assume you have a C++ compiler and you want to learn about the C++ STL stack class.

• II. INTRODUCTION

Welcome to the “C++ STL Stack Class Tutorial.”

Please copy and paste the following example program into a file your compiler can read. Then build, compile, and debug the example program. Following along, back and forth, between the tutorial and your copy of the example program will help you understand the example program functionality.

//***********************************
//C++ STL Stack Class Tutorial
//Featuring a gold coin counting class
//template stack<T>
//***********************************
#include <deque>
#include <exception>
#include <iostream>
#include <stack>

using namespace std;

template< typename T>
class CStack
{
public:

CStack( int = 5 );
//Default constructor with stack size 5.
~CStack() //Destructor.
{
delete [] CStackPtr;
}

bool push( const T & );
bool pop ( T & );

bool isEmpty( ) const
{
return top == -1;
}

bool isFull( ) const
{
return top == max -1;
}

private:

int max;
int top;
T *CStackPtr;
};

template< typename T >
//Template constructor with stack size 5.
CStack< T >::CStack( int cs )
: max( cs > 0 ? cs : 5 ),
top( -1 ),
CStackPtr( new T[ max ])
{

}

template< typename T >
bool CStack< T >::push( const T &pushValue )
{
if ( !isFull() )
{
CStackPtr[ ++top ] = pushValue;
return true;
}

return false;
}

template< typename T >
bool CStack< T >::pop( T &popValue )
{
if ( !isEmpty() )
{
popValue = CStackPtr[ top-- ];
return true;
}

return false;
}

//***********************************
// MAIN() FUNCTION.
//***********************************
int main(int argc, char* argv[])
{
int choice = 0;
bool exit = false;

//***********************************
do
{
CStack< double > doubleCStack( 10 );
//Instantiate object doubleCStack
//of type CStack.
double doubleValue = 1.0;

system("CLS");
cout << endl << endl << endl;
cout << " This is a rich person's gold stacking program." << endl << endl;
cout << " The program stacks and unstacks gold coins." << endl << endl;
cout << " The first stack is a double and holds 10 gold coins." << endl << endl;
cout << " The second stack is an int and holds 5 gold coins." << endl << endl;
cout << endl << endl;
cout << " Pushing gold coins onto the double stack." << endl;
cout << endl << endl;
cout << " ";

while ( doubleCStack.push( doubleValue ))
{
cout << doubleValue << " ";
doubleValue += 1.0;
}

cout << endl << endl;
cout << " Double stack is now full." << endl << endl;
cout << " Cannot push any more gold coins onto double stack!" << endl << endl;
cout << endl << endl;
cout << " ";
system("PAUSE");

system("CLS");
cout << endl << endl << endl;
cout << " Popping gold coins from double stack." << endl;
cout << endl << endl;
cout << " ";

while ( doubleCStack.pop( doubleValue ))
{
cout << doubleValue << " ";
}

cout << endl;
cout << " ";

cout << endl;
cout << " Double stack is now empty." << endl << endl;
cout << " Cannot pop any more gold coins from double stack!" << endl << endl;
cout << endl << endl;
cout << " ";
system("PAUSE");
cout << endl << endl << endl;
cout << " ";

CStack< int > intCStack;
//Instantiate object intCStack
//of type CStack.
int intValue = 1;

system("CLS");
cout << endl << endl << endl;
cout << " Pushing gold coins onto int stack." << endl;

cout << endl << endl;
cout << " ";

while ( intCStack.push( intValue ))
{
cout << intValue++ << " ";
}

cout << endl << endl;
cout << " Int stack is now full." << endl << endl << endl;
cout << " Cannot push any more gold coins onto int stack!" << endl << endl;

cout << endl << endl;
cout << " ";
system("PAUSE");

system("CLS");
cout << endl << endl << endl;
cout << " Popping gold coins from int stack." << endl;

cout << endl << endl;
cout << " ";

while ( intCStack.pop( intValue ))
{
cout << intValue << " ";
}

cout << endl << endl;
cout << " Int stack is now empty." << endl << endl;
cout << " Cannot pop any more gold coins from int stack!" << endl << endl;
cout << endl << endl;
cout << " ";
system("PAUSE");
cout << endl << endl << endl;
cout << " ";

//***********************************
system( "CLS" );
cout << endl << endl << endl;
cout << " Type the number 1 and press return ";
cout << "to run the program again. " << endl << endl;
cout << " Type 0 and press return to exit. ==> ";
cin >> choice;
if ( choice == 0 )
{
EXIT_SUCCESS;
}
if ( choice == 1 )
exit = false;
else
{
exit = true;
}
}while( exit == false );

return EXIT_SUCCESS;
}

• III. VOCABULARY

A. What is LIFO?

LIFO is last-in-first-out. A stack enforces LIFO order.

A stack of plates is a common visualization of a STL stack. The last plate placed on a stack of plates is normally the first plate removed from the stack of plates.

B. What is a generic function or function template?

A generic function or function template is a function definition preceded by a template statement.

template< typename T >
bool CStack< T >::push( const T &pushValue )
{
if ( !isFull() )
{
CStackPtr[ ++top ] = pushValue;
return true;
}

return false;
}

A compiler generated function specialization is an instantiation of a function template.

A function template declaration consists of the keyword template, followed by a list of template arguments enclosed in angle brackets, followed by a function declaration.

All versions of a generic function must perform the same actions, only the data type can be different. For example, a sorting algorithm is the same no mater what type of data is being sorted. You can use a generic function any time you see a situation where the logic of a function is independent of the data type. Defining a single function template defines an entire family of overloaded functions.

C. What is an explicit specialization?

A generic function overloads itself. However, the programmer can code an explicit specialization to overload a generic function and override the compiler generated function to accommodate unique situations.

D. What is a generic class?

Class is the generic term for type. A generic class is a class that uses logic that can be generalized. When objects of a generic class are created the type of data is specified as a parameter. Upon instantiation the compiler generates the correct type of object based on the parameter type specified. A generic class allows you to define the general form of an object that can then be used with any data type.

By making stack a generic class the compiler can create a stack for any type of data.

E. What is typename?

The keyword typename can be substituted for the keyword class in template declarations. The keyword typename also informs the compiler a type name is being used in a template declaration instead of an object name.

template< typename T >
bool CStack< T >::pop( T &popValue )
{
if ( !isEmpty() )
{
popValue = CStackPtr[ top-- ];
return true;
}

return false;
}

The keyword class connotes a user defined type while the keyword typename is more neutral and refers to fundamental types and user-defined types.

F. What is a class template?

A class template is a template for producing classes. A class produced from a template is said to be a class template. A template class is an instance of a class template.

Member function definitions for class templates are preceded by the template keyword with parameters in angle brackets.

G. What are container adapters?

The STL provides three container adapters: stack, queue, and priority queue. Container adapters do not support iterators. Container adapters allow you to choose an underlying data structure.

• IV. CLASS TEMPLATE STACK<T>

To instantiate a stack a data type must be specified.

The template specifications for a stack are as follows:

template <class T, class Container = deque<T>> class stack

template< typename T >
//Template constructor with stack size 5.
CStack< T >::CStack( int cs )
: max( cs > 0 ? cs : 5 ),
top( -1 ),
CStackPtr( new T[ max ])
{

}

• V. MEMBER FUNCTIONS

The main behavior of a stack is that objects go on and come off of the top of the stack. The following are STL stack class public member functions. Other underlying deque, vector, or list container member functions such as iterators, push_back, and insert been suppressed to maintain stack behavior complance.

A. void push(const value_type &val);

Inserts an element at the top of a stack. This element becomes the last in the stack.

template< typename T >
bool CStack< T >::push( const T &pushValue )
{
if ( !isFull() )
{
CStackPtr[ ++top ] = pushValue;
return true;
}

return false;
}

B. void pop();

Removes, deletes, the element at the top of a stack, the last element in the container.

template< typename T >
bool CStack< T >::pop( T &popValue )
{
if ( !isEmpty() )
{
popValue = CStackPtr[ top-- ];
return true;
}

return false;
}

C. bool empty() const;

Tests whether the stack is empty. Returns true if the stack is empty and false otherwise.

bool isEmpty( ) const
{
return top == -1;
}

D. size_type size() const;

Returns the number of elements currently in the stack.

E. value_type &top(); const value_type &top() const;

Returns a reference to the top most element in the stack. An undefined value is returned if the stack is empty.

if ( !isFull() )
{
CStackPtr[ ++top ] = pushValue;
return true;
}

• VI. CONSTRUCTOR

The stack constructor uses the following syntax to create an empty stack using deque as the default container:

explicit stack(const Container &cnt = Container());

template< typename T >
//Template constructor with stack size 5.
CStack< T >::CStack( int cs )
: max( cs > 0 ? cs : 5 ),
top( -1 ),
CStackPtr( new T[ max ])
{

}

The container is held in a protected member called c of type Container.

The ==, <, <=, !=, >, and >= comparison operators are defined for stack.

YOU HAVE LEARNED:
1. Stack class template vocabulary.
2. How to declare and use a stack class template constructor.
3. How to instantiate objects of type stack.
4. The stack class member functions and how to use them.

Elcric Otto Circle

-->

-->

-->

How to Link to My Home Page

It will appear on your website as:
"Link to ELCRIC OTTO CIRCLE's Home Page"

C++ CLASS DESIGN - CONSTRUCTORS AND DESTRUCTORS

noreply@blogger.com (Ron Tinnel) — Sat, 24 Sep 2011 20:13:00 -0400

REVISED: Sunday, March 3, 2013

CONTENTS:
• I. ASSUMPTIONS
• II. INTRODUCTION
• III. COPY CONSTRUCTOR VOCABUARY
• IV. CONSTRUCTORS
• V. OBJECTS
• VI. DATA MEMBERS
• VII. DESTRUCTORS
• VIII. MAIN FUNCTION

YOU WILL LEARN:
1. How to use constructors to specify initial values for object data members.
2. How to use object instantiation to pass data to constructors.
3. How to use Set and Get member functions to specify initial values for object data members.
4. The copy constructor vocabulary.
5. How to create and use copy constructors.

• I. ASSUMPTIONS

I assume you have a C++ compiler and you want to learn more about C++ classes.

• II. INTRODUCTION

Welcome to the “C++ CLASS DESIGN - CONSTRUCTORS AND DESTRUCTORS TUTORIAL.”

Please copy and paste the attached example program into a file your compiler can read. Then build, compile, and debug the example program. Following along, back and forth, between the tutorial and your copy of the example program will help you understand the example program functionality.

//***********************************
//C++ CLASS DESIGN -
//CONSTRUCTORS AND
//DESTRUCTORS TUTORIAL
//The tutorial includes a
//compound interest
//example which features copy
//constructors.
//***********************************
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>

using namespace std;

class CBank
{
public:

CBank( double amount, double interestEarned, double interestRate, double principle, int yearsOnDeposit, int customerNumber );
//Constructor.
//CBank(const CBank& OCharacter3); //Copy constructor.
void m_SetCustomerAccount( double amount, double interestEarned, double interestRate, double principle, int yearsOnDeposit, int customerNumber );
void m_GetCustomerAccount( double amount, double interestEarned, double interestRate, double principle, int yearsOnDeposit, int customerNumber );
void m_displayInterestEarned( );
~CBank();
private:

double itsAmount;
double itsInterestEarned;
double itsInterestRate;
double itsPrinciple;
int itsYearsOnDeposit;
int itsCustomerNumber;

};

CBank::CBank(const CBank& OCharacter3)
//Copy constructor.
{
itsAmount = OCharacter3.itsAmount;
itsInterestEarned = OCharacter3.itsInterestEarned;
itsInterestRate = OCharacter3.itsInterestRate;
itsPrinciple = OCharacter3.itsPrinciple;
itsYearsOnDeposit = OCharacter3.itsYearsOnDeposit;
}

CBank::CBank( double amount, double interestEarned, double interestRate, double principle, int yearsOnDeposit, int customerNumber )
{
m_SetCustomerAccount( amount, interestEarned, interestRate, principle, yearsOnDeposit, customerNumber );
}

void CBank::m_GetCustomerAccount( double amount, double interestEarned, double interestRate, double principle, int yearsOnDeposit, int customerNumber )
{
double xAmount = 0.0;
double xInterestRate = 0.0;
double xPrinciple = 0.0;
int xYearsOnDeposit = 0;

itsCustomerNumber = customerNumber;

system( "CLS" );
cout << endl << endl << endl;
cout << " Please type the amount you are depositing," << endl << endl;
cout << " then press Enter." << endl << endl;
cout << " For example 1000 ==> ";
cin >> xPrinciple;
cout << endl << endl << endl;
cout << " ";
system("PAUSE");
itsPrinciple = xPrinciple;

system( "CLS" );
cout << endl << endl << endl;
cout << " Please type the number of years you are investing your deposit," << endl << endl;
cout << " then press Enter." << endl << endl;
cout << " For example 1 ==> ";
cin >> xYearsOnDeposit;
cout << endl << endl << endl;
cout << " ";
system("PAUSE");
itsYearsOnDeposit = xYearsOnDeposit;

system( "CLS" );
cout << endl << endl << endl;
cout << " Please type your investment interest rate," << endl << endl;
cout << " then press Enter." << endl << endl;
cout << " For example .05 ==> ";
cin >> xInterestRate;
cout << endl << endl << endl;
cout << " ";
system("PAUSE");
itsInterestRate = xInterestRate;

for(int year = 1; year <= xYearsOnDeposit; year++)
{
xAmount = xPrinciple * pow((1 + xInterestRate), year);
}

itsAmount = xAmount;

itsInterestEarned = (xPrinciple - xAmount);
}

void CBank::m_SetCustomerAccount( double amount, double interestEarned, double interestRate, double principle, int yearsOnDeposit, int customerNumber )
{
itsAmount = amount;
itsInterestEarned = interestEarned;
itsInterestRate = interestRate;
itsPrinciple = principle;
itsYearsOnDeposit = yearsOnDeposit;
itsCustomerNumber = customerNumber;

if (itsCustomerNumber == 3)
{
customerNumber = 3;
m_GetCustomerAccount( amount, interestEarned, interestRate, principle, yearsOnDeposit, customerNumber );
}
}

void CBank::m_displayInterestEarned()
{
cout << endl << endl << endl;
cout << " COMPOUND INTEREST IS INTEREST THAT EARNS INTEREST" << endl << endl << endl;
cout << " CUSTOMER" << itsCustomerNumber << endl << endl;
cout << " AMOUNT DEPOSITED: " << itsPrinciple << endl << endl;
cout << " INTEREST RATE: " << itsInterestRate << endl << endl;
cout << " YEARS LEFT IN BANK: " << itsYearsOnDeposit << endl << endl << endl;
cout << " END OF TOTAL AMOUNT" << " TOTAL INTEREST" << endl;
cout << " YEAR" << setw(21) << " ON DEPOSIT" << setw(18) << "EARNED" << endl;
cout << " ----" << setw(21) << " ----------" << setw(18) << "------" << endl;
cout << fixed << setprecision(2);
for(int year = 1; year <= itsYearsOnDeposit; year++)
{
itsAmount = itsPrinciple * pow((1 + itsInterestRate), year); //pow(base, exponent)
cout << " " << setw(4) << year << setw(21) << itsAmount << setw(18) << (itsAmount-itsPrinciple)<< endl;
}
}

CBank::~CBank()
{

}

//***********************************
// MAIN() FUNCTION.
//***********************************
int main(int argc, char* argv[])
{
int choice = 0;
bool exit = false;

//***********************************
do
{
system( "CLS" );
CBank OCustomer1( 0.00, 0.00, 0.00, 0.00, 0, 1 );
OCustomer1.m_displayInterestEarned();
cout << endl << endl << endl;
cout << " ";
system("PAUSE");

system( "CLS" );
CBank OCustomer2( 1050.00, 50.00, .05, 1000.00, 1, 2 );
OCustomer2.m_displayInterestEarned();
cout << endl << endl << endl;
cout << " ";
system("PAUSE");

system( "CLS" );
CBank OCustomer3( 0.00, 0.00, 0.00, 0.00, 0, 3 );
OCustomer3.m_displayInterestEarned();
cout << endl << endl << endl;
cout << " ";
system("PAUSE");

system( "CLS" );
CBank OCustomer4( 0.00, 0.00, 0.00, 0.00, 0, 4 );
//Copy OCustomer3 interestRate,
//principle, and yearsOnDeposit
//to OCustomer4, then compute the
//OCustomer4 interestEarned
//and amount.

OCustomer4 = OCustomer3;
//Calls copy constructor.
OCustomer4.m_displayInterestEarned();
cout << endl << endl << endl;
cout << " ";
system("PAUSE");

//***********************************
system( "CLS" );
cout << endl << endl << endl;
cout << " Type the number 1 and press return ";
cout << "to run the program again. " << endl << endl;
cout << " Type 0 and press return to exit. ==> ";
cin >> choice;
if ( choice == 0 )
{
OCustomer1.~CBank();
//These destructors are not
//really necessary.
OCustomer2.~CBank();
//Just shown for demonstration purposes.
OCustomer3.~CBank();
OCustomer4.~CBank();
EXIT_SUCCESS;
}
if ( choice == 1 )
exit = false;
else
{
OCustomer1.~CBank();
//These destructors are not
//really necessary.
OCustomer2.~CBank();
//Just shown for demonstration purposes.
OCustomer3.~CBank();
OCustomer4.~CBank();
exit = true;
}
}while( exit == false );

return EXIT_SUCCESS;
}

• III. COPY CONSTRUCTOR VOCABULARY

A. What is a pointer?

To use pointers you should understand the difference between a pointer; the address the pointer contains; and the value at the address the pointer contains.

Step 1: Declare and initialize the pointer.

A pointer is a variable that holds a memory address.

The syntax for declaring and initializing a pointer is as follows:

type *pointer_Name = 0;

It is good programming practice to name pointers with an initial p; for example:

double *pB = 0;

In the pointer declaration the pointer asterisk follows the type of the object pointed to.

Step 2: Assign the pointer an address.

Before a pointer can contain an address the address must be assigned to the pointer.

double a = 10.00;

pB = &a;

Step 3: Pointer dereference or indirection to get the value.

A pointer provides indirect access to the value of the variable whose address it stores. As a dereference or indirection operator the pointer asterisk indicates that the value at the memory address is to be accessed instead of the address itself.

cout << *pB;

Displays 10.00

B. What is a try block?

Exceptions arise due to predictable problems such as running out of memory or disk space. You use a try block to tell the compiler to watch code that might create exceptions during execution. You create a try block by adding the keyword try and braces around any code which could cause exceptions

The keyword throw can be used to test a try block. The syntax for the keyword throw is as follows:

throw exception;

C. What is a catch block?

When a try block is executed, if an exception occurs, it is said to be thrown. Thrown exceptions can then be caught with a catch block. A catch block begins with the keyword catch, followed by an exception type in parentheses, followed by an opening brace, and ending with a closing brace.

When an exception is thrown it is sent to the first catch block following the try block. The compiler executes the catch block if the exception type in the catch block’s parameter parentheses matches the thrown exception. If there is no match the next catch block’s exception parameter parentheses is checked, and so on, until a match is found and that matching catch block is executed. When you code a catch block you can include a specific exception as a parameter in the catch block’s parameter parentheses or use the ellipsis … as an all inclusive exception parameter in the catch block’s parameter parentheses.

D. What is the keyword const?

You use the keyword const to define constants, this allows the compiler to enforce the usage of the type.

E. What is put()?

put() is a function that writes a single character to the output device.

F. What is get()?

get() is a function that obtains a single character from an input device.

G. What is overload?

When you overload a method you create more than one method with the same name but with a different signature.

H. What is override?

When you override a method you create a method in a derived class with the same name as the method in the base class and the same signature.

I. What is a base class?

A class that adds new functionality to an existing class is said to derive from that original class. The original class is said to be the new class’s base class.

Base class initialization can be performed during class initialization by writing the base class name followed by the parameters expected by the base class.

J. What is a derived class?

A class that adds new functionality to an existing class is said to derive from that original class.

K. What is a signature?

The signature is the function prototype other than the return type: the name of the function, the parameter list, and the keyword const if it is used.

In the attached example program the class of the object being copied is CBank, and the copy constructor’s signature is:

CBank::CBank (const CBank &);

L. What is a shallow copy?

Bitwise, bit-by-bit, copies of objects are shallow copies. If A and B are shallow copies, they are not separate and distinct objects, they both have the same memory storage location. Changing the value of A makes B have the same value. A shallow copy is fast when compared to a deep copy.

M. What is a deep copy?

A deep copy is not a bitwise, bit-by-bit, copy. If A and B are deep copies, they are separate and distinct objects, each has its own unique memory storage location. Changing the value of A does not change the value of B. A deep copy is comparatively slower than a shallow copy.

O. What is a lazy copy?

A lazy copy is initially a shallow copy. It has the speed of a shallow copy. When the object that was lazy copied is needed the compiler does a deep copy before use.

P. What is rhs?

rhs means right-hand-side of the equal sign. And, lhs means left hand side of the equal sign.

• IV. CONSTRUCTOR

A constructor is a function with the same name as the class. The tasks performed by a constructor are to create a new instance of the class and initialize the data members of the new instance.

Constructors are normally declared public and defined with the same name as the class. If a class does not include a constructor the compiler includes a default constructor with no parameters and no return type. Constructors can not specify a return type, not even void. Constructors cannot be virtual. The compiler default constructor allocates memory for the class object; however, it does not initialize the class object’s data members.

A class can have several constructors.

A. Constructor with parameters.

Using data members before they have been properly initialized can cause logic errors. It is good programming practice to declare a constructor that initializes your class object data members with meaningful values each time a new object of the class is created, instantiated. A constructor specifies in its parameter list the data it requires to initialize the class object’s data members.

CBank( double amount, double interestEarned, double interestRate, double principle, int yearsOnDeposit, int customerNumber );

When you create a new object you place the data required by the constructor in the parentheses following the objects name.

CBank OCustomer2( 1050.00, 50.00, .05, 1000.00, 1, 2 );

B. Copy constructor

The compiler automatically creates an implicit copy constructor for each class. The copy constructor created by the programmer is an explicit copy constructor. A copy constructor is a special constructor that allows the programmer to create a new object from an existing object by initialization. The copy constructor creates a new object of the same class and copies the value of the data members from the calling object into the new object’s data members.

The syntax for a copy constructor is as follows:

Class_name::Class_name(const Class_name & Object_Being_Copied);

The syntax for the copy constructor used in the example program is as follows:

CBank::CBank(const CBank& OCharacter3);

C++ performs a bitwise, bit-by-bit, copy when one object is used to initialize another. An identical copy of the initializing object is created in the target object. The target object does not create its own memory it uses the same memory as the initializing object. This also happens when a copy of an object is made when it is passed as an argument to a function, and when a temporary object is made as a return value from a function. Using a copy constructor solves this same memory usage problem by bypassing the bitwise, bit-by-bit, copy.

The assignment operator copies to existing objects, and the copy constructor copies to newly created objects. If a new object has to be created before the copying can occur, the copy constructor is used. If a new object does not have to be created before the copying can occur, the assignment operator is used.

Assignment and initialization are two situations in which the value of one object is given to another. The copy constructor applies only to initializations.

There are three general cases where the copy constructor is called instead of the assignment operator:

First, when a temporary object is made as a return value from a function;

for example:

a = function();

Second, when a copy of an object is made to be passed by value as a parameter to a function; for example:

function(a);

Third, when one object initializes another through a declaration; for example, class instantiation object b = a;.

In each of these cases, a new variable needs to be created before the values can be copied.

A copy constructor looks just like a normal constructor that takes a class data member parameter; however, the parameter must be passed by reference, and not by value.

The following is a copy constructor used in the following example program.

CBank::CBank(const CBank& OCharacter3)
//Copy constructor.
{
itsAmount = OCharacter3.itsAmount;
itsInterestEarned = OCharacter3.itsInterestEarned;
itsInterestRate = OCharacter3.itsInterestRate;
itsPrinciple = OCharacter3.itsPrinciple;
itsYearsOnDeposit = OCharacter3.itsYearsOnDeposit;
}

• V. OBJECTS

C++ allows objects to initialize themselves when they are created. This automatic initialization is performed through the use of a constructor function.

CBank( double amount, double interestEarned, double interestRate, double principle, int yearsOnDeposit, int customerNumber );

system( "CLS" );
CBank OCustomer2( 1050.00, 50.00, .05, 1000.00, 1, 2 );
OCustomer2.m_displayInterestEarned();
cout << endl << endl << endl;
cout << " ";
system("PAUSE");

An object is an individual instance of a class. When a program creates, instantiates, an object of a class, its private data members are encapsulated, hidden, and can be accessed only by member functions of the object’s class. Set and Get member functions of the object’s class allow clients of a class to access the hidden data.

• VI. DATA MEMBERS

Member variables also known as data members are the class variables. As a general rule you should keep the data members of a class private.

private:

double itsAmount;
double itsInterestEarned;
double itsInterestRate;
double itsPrinciple;
int itsYearsOnDeposit;
int itsCustomerNumber;

};

The private and public keywords enable a feature known as data hiding. To access private data in a class, you must create public functions known as accessor methods. These accessor methods are the member functions that other parts of your program call to Get and Set private member variables.

void CBank::m_GetCustomerAccount( double amount, double interestEarned, double interestRate, double principle, int yearsOnDeposit, int customerNumber )
{
double xAmount = 0.0;
double xInterestRate = 0.0;
double xPrinciple = 0.0;
int xYearsOnDeposit = 0;

itsCustomerNumber = customerNumber;

system( "CLS" );
cout << endl << endl << endl;
cout << " Please type the amount you are depositing," << endl << endl;
cout << " then press Enter." << endl << endl;
cout << " For example 1000 ==> ";
cin >> xPrinciple;
cout << endl << endl << endl;
cout << " ";
system("PAUSE");
itsPrinciple = xPrinciple;

system( "CLS" );
cout << endl << endl << endl;
cout << " Please type the number of years you are investing your deposit," << endl << endl;
cout << " then press Enter." << endl << endl;
cout << " For example 1 ==> ";
cin >> xYearsOnDeposit;
cout << endl << endl << endl;
cout << " ";
system("PAUSE");
itsYearsOnDeposit = xYearsOnDeposit;

system( "CLS" );
cout << endl << endl << endl;
cout << " Please type your investment interest rate," << endl << endl;
cout << " then press Enter." << endl << endl;
cout << " For example .05 ==> ";
cin >> xInterestRate;
cout << endl << endl << endl;
cout << " ";
system("PAUSE");
itsInterestRate = xInterestRate;

for(int year = 1; year <= xYearsOnDeposit; year++)
{
xAmount = xPrinciple * pow((1 + xInterestRate), year);
}

itsAmount = xAmount;

itsInterestEarned = (xPrinciple - xAmount);
}

void CBank::m_SetCustomerAccount( double amount, double interestEarned, double interestRate, double principle, int yearsOnDeposit, int customerNumber )
{
itsAmount = amount;
itsInterestEarned = interestEarned;
itsInterestRate = interestRate;
itsPrinciple = principle;
itsYearsOnDeposit = yearsOnDeposit;
itsCustomerNumber = customerNumber;

if (itsCustomerNumber == 3)
{
customerNumber = 3;
m_GetCustomerAccount( amount, interestEarned, interestRate, principle, yearsOnDeposit, customerNumber );
}
}

As shown above, each member function call tells the object to perform a task.

• VII. DESTRUCTORS

The name of a destructor for a class is the tilde character ~ followed by the class name. A destructor receives no parameters and returns no value. A destructor may not specify a return type, not even void. A destructor must be public. Since a destructor has no parameters, a class can only have one destructor; however, this destructor can be called many times. If you do not provide a destructor the compiler provides an empty destructor with no parameters and no return type.

The destructor is called automatically by the compiler when the program execution leaves the scope within which an object was instantiated.

• VIII. MAIN FUNCTION

A function in a class is known as a member function and performs one of the class’s tasks. An empty set of parentheses following a member function name indicates the member function does not require any additional data to perform its task. Control statements specify the order in which the member function’s tasks are performed. Conventional programming practice is to start the name of a member function with a lower case letter and use a capital letter to start each additional word in the member function name.

//***********************************
// MAIN() FUNCTION.
//***********************************
int main(int argc, char* argv[])
{
int choice = 0;
bool exit = false;

//***********************************
do
{
system( "CLS" );
CBank OCustomer1( 0.00, 0.00, 0.00, 0.00, 0, 1 );
OCustomer1.m_displayInterestEarned();
cout << endl << endl << endl;
cout << " ";
system("PAUSE");

system( "CLS" );
CBank OCustomer2( 1050.00, 50.00, .05, 1000.00, 1, 2 );
OCustomer2.m_displayInterestEarned();
cout << endl << endl << endl;
cout << " ";
system("PAUSE");

system( "CLS" );
CBank OCustomer3( 0.00, 0.00, 0.00, 0.00, 0, 3 );
OCustomer3.m_displayInterestEarned();
cout << endl << endl << endl;
cout << " ";
system("PAUSE");

system( "CLS" );
CBank OCustomer4( 0.00, 0.00, 0.00, 0.00, 0, 4 );
//Copy OCustomer3 interestRate,
//principle, and yearsOnDeposit
//to OCustomer4, then compute the
//OCustomer4 interestEarned
//and amount.

OCustomer4 = OCustomer3;
//Calls copy constructor.
OCustomer4.m_displayInterestEarned();
cout << endl << endl << endl;
cout << " ";
system("PAUSE");

//***********************************
system( "CLS" );
cout << endl << endl << endl;
cout << " Type the number 1 and press return ";
cout << "to run the program again. " << endl << endl;
cout << " Type 0 and press return to exit. ==> ";
cin >> choice;
if ( choice == 0 )
{
OCustomer1.~CBank();
//These destructors are not
//really necessary.
OCustomer2.~CBank();
//Just shown for demonstration purposes.
OCustomer3.~CBank();
OCustomer4.~CBank();
EXIT_SUCCESS;
}
if ( choice == 1 )
exit = false;
else
{
OCustomer1.~CBank();
//These destructors are
//not really necessary.
OCustomer2.~CBank();
//Just shown for demonstration purposes.
OCustomer3.~CBank();
OCustomer4.~CBank();
exit = true;
}
}while( exit == false );

return EXIT_SUCCESS;
}

A class member function is called by following an object name with the dot . operator, followed by the member function name and a set of parentheses listing the member function’s arguments.

YOU HAVE LEARNED:
1. How to use constructors to specify initial values for object data members.
2. How to use object instantiation to pass data to constructors.
3. How to use Set and Get member functions to specify initial values for object data members.
4. The copy constructor vocabulary.
5. How to create and use copy constructors.

Elcric Otto Circle

-->

-->

-->

How to Link to My Home Page

It will appear on your website as:
"Link to ELCRIC OTTO CIRCLE's Home Page"

C++ CLASS DESIGN - PARAMETERS AND ARGUMENTS

noreply@blogger.com (Ron Tinnel) — Sat, 24 Sep 2011 19:44:00 -0400

REVISED: Sunday, March 3, 2013

CONTENTS:
• I. ASSUMPTIONS
• II. INTRODUCTION
• III. OBJECTS
• IV. DATA MEMBERS
• V. SCOPE
• VI. PARAMETERS AND ARGUMENTS
• VII. MAIN FUNCTION

YOU WILL LEARN:
1. How to instantiate or declare a class object.
2. How to keep the data members of a class private.
3. How to create public functions known as accessor methods.
4. How to successfully implement function prototype scope.
5. The difference between parameters and arguments.

• I. ASSUMPTIONS

I assume you have a C++ compiler and you want to learn more about C++ classes.

• II. INTRODUCTION

Welcome to the “C++ CLASS DESIGN - PARAMETERS AND ARGUMENTS TUTORIAL.”

Please copy and paste the attached program into a file your compiler can read. Then build, compile, and debug the program. Following along, back and forth, between the tutorial and your copy of the program will help you understand the program functionality.

//***********************************
//C++ CLASS DESIGN - PARAMETERS
//AND ARGUMENTS TUTORIAL
//With a sphere class object's data
//member variables example.
//***********************************
#include <cmath>
#include <iomanip>
#include <iostream>

using namespace std;

const double PI = 3.14159;

//***********************************
// Class CSphere
//***********************************
class CSphere
{
public:
CSphere();
void m_getRadiusSphere();
//Radius of circle.
void m_DiameterSphere();
//Diameter of circle.
void m_AreaCircle();
//Area of circle.
void m_CircumferenceSphere();
//Circumference of circle.
void m_VolumeSphere();
//Volume of sphere.
void m_DisplayPublicSphere();
//Dispalys properties of sphere.
~CSphere();

private:

double a;
//Area of circle.
double c;
//Circumference of circle.
double d;
//Diameter of circle.
double r;
//Radius of circle.
double v;
//Volume of sphere.
};

//***********************************
//Constructor of sphere class.
//***********************************
CSphere::CSphere()
{

}

//***********************************
//Radius of circle.
//***********************************
void CSphere::m_getRadiusSphere()
{
cout << endl << endl << endl;
cout << " C++ CLASS DESIGN - PARAMETERS AND ARGUMENTS TUTORIAL" << endl;
cout << " ----------------------------------------------" << endl << endl;
cout << " Please enter radius of sphere." << endl << endl;
cout << " For example; 1 and then press Enter ==> ";
cin >> r;
//Obtain value for Radius.
}

//***********************************
//Computes diameter of circle, equals
//d = (r * 2);
//***********************************
void CSphere::m_DiameterSphere()
{
d = (r * 2);
}

//***********************************
//Computes area of circle, equals
//a = (PI * pow(Radius, 2));
//***********************************
void CSphere::m_AreaCircle()
{
a = (PI * pow(r, 2));
}

//***********************************
//Computes circumference
//of circle, equals
//c = (2*PI*Radius);
//***********************************
void CSphere::m_CircumferenceSphere()
{
c = (2 * PI * r);
}

//***********************************
//Computes volume of a sphere, equals
//v = (((4/3) * PI) * pow(Radius, 3));
//***********************************
void CSphere::m_VolumeSphere()
{
v = (((4 / 3) * PI) * pow( r, 3 ));
}

//***********************************
//Displays properties of sphere.
//***********************************
void CSphere::m_DisplayPublicSphere()
{

cout << endl << endl << endl;
cout << " C++ CLASS DESIGN - PARAMETERS AND ARGUMENTS TUTORIAL " << endl;
cout << " ----------------------------------------------------" << endl << endl;
cout << " SPHERE " << endl << endl;
cout << " ----------------------------------------------------" << endl << endl;
cout << " r = Radius r = " << r << endl;
cout << " " << endl << endl;
cout << " ----------------------------------------------------" << endl << endl;
cout << " a = Area of circle within sphere a = " << a << endl;
cout << " a = (PI * pow(r, 2)) " << endl << endl;
cout << " ----------------------------------------------------" << endl << endl;
cout << " c = Circumference of circle c = " << c << endl;
cout << " c = (2 * PI * r) " << endl << endl;
cout << " ----------------------------------------------------" << endl << endl;
cout << " d = Diameter of circle d = " << d << endl;
cout << " d = (r * 2) " << endl << endl;
cout << " ----------------------------------------------------" << endl << endl;
cout << " v = Volume of sphere v = " << v << endl;
cout << " v = (((4 / 3) * PI) * pow( r, 3 )) " << endl << endl;
cout << " ----------------------------------------------------" << endl << endl;
}

//***********************************
//Destructor of sphere class.
//***********************************
CSphere::~CSphere()
{

}

//***********************************
// MAIN() FUNCTION.
//***********************************
int main(int argc, char* argv[])
{
int choice = 0;
bool exitt = false;

CSphere OSun;
//Instantiates object OSun
//of type class CSphere.

do
{
OSun.m_getRadiusSphere();
OSun.m_DiameterSphere();
OSun.m_AreaCircle();
OSun.m_CircumferenceSphere();
OSun.m_VolumeSphere();

//***********************************
system("CLS");
cout << endl << endl << endl;
OSun.m_DisplayPublicSphere();
cout << endl << endl << endl;
cout << " ";
system("PAUSE");
OSun.~CSphere();

//***********************************
system("CLS");
cout << endl << endl << endl;
cout << " Type the number 1 and press return ";
cout << "to run the program again. " << endl << endl;
cout << " Type 0 and press return to exit. ==> ";
cin >> choice;
if (choice == 0) EXIT_SUCCESS;
if (choice == 1)
exitt = false;
else
exitt = true;
}while(exitt == false);

return EXIT_SUCCESS;
}

III. OBJECTS

Objects are reusable software components that model items in the real world. You can not call a member function of a class until you create an object of that class.

The syntax for instantiating or declaring a class object is as follows:

Class_Name Object_Name;

An example of the syntax used in the attached program is as follows:

CSphere OSun;

The object you create only contains data. All objects of a class share the class member functions. However, the data contained in class object data members varies.

IV. DATA MEMBERS

Data members are declared inside a class definition but outside the bodies of the class member function definitions.

Each object has its own copy of its data members. However, each object shares the class member functions.

Member variables also known as data members are the class variables. A class also contains functions called member functions or methods which determine what a class can do. The member functions in a class manipulate the member variables. Collectively, the data members and member functions are called the class’s members.

As a general rule you should keep the data members of a class private. The private and public keywords enable a feature known as data hiding.

private:

double a;
//Area of circle.
  double c;
//Circumference of circle.
  double d;
//Diameter of circle.
  double r;
//Radius of circle.
  double v;
//Volume of sphere.

C++ ensures that programmers cannot access private data members outside the class unintentionally.

To access private data in a class, you must create public functions known as accessor methods.

//***********************************
//Computes diameter of circle, equals
//d = (r * 2);
//***********************************
void CSphere::m_DiameterSphere()
{
d = (r * 2);
}

//***********************************
//Computes area of circle, equals
//a = (PI * pow(Radius, 2));
//***********************************
void CSphere::m_AreaCircle()
{
a = (PI * pow(r, 2));
}

//***********************************
//Computes circumference of circle, equals
//c = (2*PI*Radius);
//***********************************
void CSphere::m_CircumferenceSphere()
{
c = (2 * PI * r);
}

//***********************************
//Computes volume of a sphere, equals
//v = (((4/3) * PI) * pow(Radius, 3));
//***********************************
void CSphere::m_VolumeSphere()
{
v = (((4 / 3) * PI) * pow( r, 3 ));
}

These accessor methods are the member functions that other parts of your program call to get and set private member variables. Accessor functions enable the separation of the details of how the data is stored, from how the data is used.

• V. SCOPE

The scope of a variable specifies where it can be used in a program. You get a compiler error when variables that have the same name do not have different scopes. To accommodate these types of problems C++ has several scopes; for example:

A. Function scope.

Variables defined in a member function definition’s body are known as local variables. A local variable must be declared before it can be used. The scope of the local variable is the function in which it is declared. A local variable can not be used outside of the scope of its declaring function. When a function terminates the values of its local variables are destroyed unless they have been declared as static.

Local variables declared as static retain their values when the function within which they have been declared completes. The local variables declared as static are only known in the function in which they are declared. The next time the function containing the static local variables is called the static local variables retain the values they had when the function was last executed.

Labels, identifiers followed by a colon, have function scope.

B. File scope.

A file is the program source code file.

Global variables, global functions, function prototypes, and function definitions placed outside a function all have file scope.

C. Block scope.

Code with braces {…} is a block.

Identifiers declared inside a block have block scope.

Variables declared in a class member function have block scope.

Function parameters, local variables of the function, have block scope.

When blocks are nested and an identifier in an inner block has the same name as an identifier in an outer block. The identifier with the same name in the outer block is hidden until the inner block completes. During the execution of the inner block, the inner block only has awareness of its own identifier’s value. During execution, the inner block has no awareness of the outer block identifier with the same name’s value. If your program code intends to have the outer block executing simultaneously with the inner block the compiler will give you a logic error. It is good programming practice to avoid using duplicate identifier names in a program.

D. Function prototype scope.

The function prototype is the declaration of the function and tells the compiler the name of the function, the function’s return type, and the function’s parameters type, number, and order.

public:
CSphere();
void m_getRadiusSphere();
//Radius of circle.
void m_DiameterSphere();
//Diameter of circle.
void m_AreaCircle();
//Area of circle.
void m_CircumferenceSphere();
//Circumference of circle.
void m_VolumeSphere();
//Volume of sphere.
void m_DisplayPublicSphere();
//Dispalys properties of sphere.

The function signature is the part of the function prototype that includes the name of the function and the types of its parameters. The function signature does not include the function return type. Functions in the same scope must have unique signatures.

E. Class scope.

The class scope starts with the keyword class, includes the class definition body block within the braces {…}, the class’s class members, class data members, and class member functions.

Within a class’s scope, class members are accessible by all of that class’s member functions and can be referenced by name.

Outside a class’s scope, public class members are referenced by an objects name, a reference to an object, or a pointer to an object. The dot member selection operator (.) is preceded by an objects name to access the object’s members. The arrow member selection operator (->) is preceded by a pointer to an object to access the object’s members.

F. Namespace scope.

Each namespace defines a scope within which identifiers and variables are placed.

To use a namespace member, either the member’s name must be qualified with the namespace name and the binary scope resolution operator ::, or a using declaration or using directive must appear before the name is used in the program. A using declaration; for example, “using std::endl;” brings one name into the scope where the declaration appears. A using directive; for example, “using namespace std;” brings all the names from the namespace into the scope where the directive appears.

• VI. PARAMETERS AND ARGUMENTS

Parameters and arguments are often used as synonyms; however, they have unique meanings. Parameters refer to the function’s declaration and definition. Arguments refer to the function’s call. A function can specify multiple parameters by separating each parameter from the next with a comma. The number and order of arguments in a function call must match the number and order of the parameters in the parameter list of the called member function’s declaration and definition. In addition, the argument types in the function call must be consistent with the corresponding parameter types in the parameter list of the called member function’s declaration and definition.

Four steps are involved in using a class member function.

A. First declare the class member function.

Member function declarations or prototypes do not require names in the parameter list; only types are required. The compiler ignores names if they are used. However, programmers sometimes include names to help them document the program.

The syntax for declaring a class member function is as follows:

Type function_Name(parameter_type_list);

An example of the syntax used in the attached program is as follows:

void m_getDiameterSphere();

B. Second define the class member function.

The syntax for defining a class member function is as follows:

Type Class_Name::member_Function_Name(parameters);

An example of the syntax used in the attached program is as follows:

void CSphere::m_DiameterSphere();

C. Third, code the class member function call and make sure the type, order, and the number of parameters of the called member function’s declaration and definition; and the type, order, and the number of the function call arguments are in agreement.

D. Fourth call the class member function.

The syntax for calling a class member function is as follows:

Object.member_Function_Name (Arguments);

An example of the syntax used in the attached program is as follows:

OSun.m_DiameterSphere();

To avoid ambiguity, do not use the same names for the arguments passed to a function and the corresponding parameters in the function definition.

• VII. MAIN FUNCTION

The function main() is always called automatically when you execute a program.

The main() function creates objects from classes.

//***********************************
// MAIN() FUNCTION.
//***********************************
int main(int argc, char* argv[])
{
int choice = 0;
bool exitt = false;

CSphere OSun;
//Instantiates object OSun
//of type class CSphere.

do
{
OSun.m_getRadiusSphere();
OSun.m_DiameterSphere();
OSun.m_AreaCircle();
OSun.m_CircumferenceSphere();
OSun.m_VolumeSphere();

//***********************************
system("CLS");
cout << endl << endl << endl;
OSun.m_DisplayPublicSphere();
cout << endl << endl << endl;
cout << " ";
system("PAUSE");
OSun.~CSphere();

//***********************************
system("CLS");
cout << endl << endl << endl;
cout << " Type the number 1 and press return ";
cout << "to run the program again. " << endl << endl;
cout << " Type 0 and press return to exit. ==> ";
cin >> choice;
if (choice == 0) EXIT_SUCCESS;
if (choice == 1)
exitt = false;
else
exitt = true;
}while(exitt == false);

return EXIT_SUCCESS;
}

The main() function then calls member functions for the objects to accomplish the work of the program. Member functions may create other objects or call other functions. Within each function call, local objects are destroyed when the function completes. When the main() function completes, the objects the main() function has created are also destroyed.

YOU HAVE LEARNED:
1. How to instantiate or declare a class object.
2. How to keep the data members of a class private.
3. How to create public functions known as accessor methods.
4. How to successfully implement function prototype scope.
5. The difference between parameters and arguments.

Elcric Otto Circle

-->

-->

-->

How to Link to My Home Page

It will appear on your website as:
"Link to ELCRIC OTTO CIRCLE's Home Page"