Techniques of Using Variables |
|
A reference is a variable name that is a duplicate of an
existing variable. It provides a techniques of creating more than one name to
designate the same variable. The syntax of creating or declaring a reference is:
DataType &ReferenceName = VariableName;
To declare a reference, type the variable’s name preceded
by the same type as the variable it is referring to. Between the data type and
the reference name, type the ampersand operator “&”. To specify what
variable the reference is addressed to, use the assignment operator “=”
followed by the name of the variable. The referred to variable must exist
already. You cannot declare a reference as:
int &Mine;
The compiler wants to know what variable you are referring
to. Here is an example:
//---------------------------------------------------------------------------
#include <iostream.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
int Number = 228;
int &Nbr = Number;
cout << "\n\nPress any key to continue...";
getchar();
return 0;
}
//---------------------------------------------------------------------------
|
The ampersand operator between the data type and the reference can assume one
of three positions as followed:
int& Nbr;
int & Nbr;
int &Nbr;
As long as the & symbol is between a valid data type and a variable name,
the compiler knows that the variable name (in this case Nbr) is a reference.
Once a reference has been initialized, it holds the same value as the
variable it is pointing to. You can then display the value of the variable using
either of both:
//---------------------------------------------------------------------------
#include <iostream.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
int Number = 228;
int & Nbr = Number;
cout << "Number = " << Number << "\n";
cout << "Its reference = " << Nbr;
cout << "\n\nPress any key to continue...";
getchar();
return 0;
}
//---------------------------------------------------------------------------
|
If you change the value of the variable, the compiler
updates the value of the reference so that both variable would hold the same
value. In the same way, you can modify the value of the reference, which would
update the value of the referred to variable. To access the reference, do not
use the ampersand operator; just the name of the reference is sufficient to the
compiler. This is illustrated in the following:
//---------------------------------------------------------------------------
#include <vcl.h>
#include <iostream.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
int Number = 228; // Regular variable
int& Nbr = Number; // Reference
cout << "Number = " << Number << "\n";
cout << "Its reference = " << Nbr << "\n";
// Changing the value of the original variable
Number = 4250;
cout << "\nNumber = " << Number;
cout << "\nIts reference = " << Nbr << "\n";
// Modifying the value of the reference
Nbr = 38570;
cout << "\nNumber = " << Number;
cout << "\nIts reference = " << Nbr;
cout << "\n\nPress any key to continue...";
getchar();
return 0;
}
//---------------------------------------------------------------------------
|
In the way, you can use either a reference or the variable
it is referring to, to request the variable’s value from the user. Here is an
example:
//---------------------------------------------------------------------------
#include <vcl.h>
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
double Price;
double& RefPrice = Price;
cout << "What's the price? $";
cin >> Price;
cout << "Price = $" << Price << "\n";
cout << "Same as $" << RefPrice << "\n\n";
cout << "What's the price? $";
cin >> RefPrice;
cout << "Price = $" << Price << "\n";
cout << "Same as $" << RefPrice << "\n";
cout << "\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
The typedef Type Definition
|
|
Some of the identifiers we have used so far and some others
we will learn further with arrays, pointers, and objects can be simplified and
reduced to a new one-word identifier. C++ allows you to define a new variable
using typedef. Indeed, typedef is not a new or other identifier.
It provides a technique of redefining any of the known identifiers or by naming
those that are combined.
The formula of using the typedef is:
typedef Identifier NewName;
The typedef word is required to let the compiler know
that you are creating a new identifier. The Identifier is any of those we have
learned so far. It could be an int, an unsigned int, a char, a double, etc. An
example of declaring a typedef is:
typedef int NumberOfStudents;
In this case, NumberOfStudents is just a new name for an
int. It can be used as a new identifier exactly as if you were using an int.
Here is an example that redefines an int identifier:
//---------------------------------------------------------------------------
#include <vcl.h>
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
typedef int NumberOfStudents;
NumberOfStudents Grade1, Grade2;
cout << "Enter the number of students.\n";
cout << "Grade 1: ";
cin >> Grade1;
cout << "Grade 2: ";
cin >> Grade2;
cout << "\nNumber of students:";
cout << "\n1st Grade: " << Grade1;
cout << "\n2nd Grade: " << Grade2;
cout << "\n\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
Here are examples of creating new identifiers using typedef:
typedef unsigned int uInt;
typedef unsigned char uChar;
typedef unsigned long uLong;
typedef long double lDouble;
|
The compiler you are using shipped with a lot of data types, some of which
are redefined versions of existing C++ data types. Therefore, the identifiers
you will be using in C++ Builder come in three sets. The C++ language has its
own data types that are integers, floating values, etc. Borland C++ Builder has
a list of redefined types in the sysmac.h library. The Microsoft Windows
operating systems ships with the Win32 library that has a set of redefined data
types. To see its list, in the MSDN library, do a search on Data Types [Win32].
In this book, we will interchangeably use any data type we see fit for the
task at hand, without identifying whether it is part of C++, Borland C++
Builder, or Win32. For that reason, from now on, many of our programs will
include the VCL library.
Practical Learning: Using the typedef Keyword
|
|
- To open WordPad, from the Taskbar, click Start -> Programs ->
Accessories -> WordPad.
- Locate the C:\Program Files\Borland\CBuilder5\Include\Vcl folder.
- Double-click sysmac to open that header file.
- Scroll down to locate the section with the type definitions.
- Close WordPad. If you are asked to save anything, click No.
A constant is a value that does not change. There are
various categories of constants you will be using in your programming life:
Those that are mathematically defined (such as numbers); those that are defined
by, and are part of, the C++ language; those defined by the Microsoft Windows
operating system you are using, and those defined by the Borland C++ Builder
compiler or libraries. To make their management easier, these constant values
have been categorized and defined in particular libraries. Throughout this book,
you will be using them.
The algebraic numbers you have been using all the time are
constants because they never change. Examples of constant numbers are 12, 0,
1505, or 88146. Therefore, any number you can think of is a constant.
Every letter of the alphabet is a constant and is always the
same. Examples of constant letters are d, n, c.
Some characters on your keyboard represent symbols that are
neither letters nor digits. These are constants too. Examples are #, &, |,
!.
Some values would be constant by default, but their
constancy sometimes depends on the programmer. For example, one programmer can
define a const PI as 3.14; another programmer can decide that the constant PI
would be 3.14159; yet another programmer would use a more precise value.
Therefore, you will be defining your own constant values as you see fit for the
goal you are trying to achieve.
There are two main techniques you use to display a constant
value in C++. To simply display it using the cout operator, you can use its
value on the right side of the << symbols. You can also define it first
using an appropriate name, and then using that name to display the constant.
Practical Learning: Using Constant Values
|
|
- On the Standard toolbar, click the New button
- On the New Items dialog, click Console Wizard and click OK
- On the Console Wizard dialog, make sure that the C++ radio button, the
VCL, and the Console Application check boxes are selected:
- Click OK
- Change the content of the file as follows:
//---------------------------------------------------------------------------
#include <vcl.h>
#include <iostream.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
cout << 28;
cout << "\nStudent Age: " << 14;
cout << "\n\nPress any key to continue...";
getchar();
return 0;
}
//---------------------------------------------------------------------------
|
- To test the program, press F9
Creating Custom Constants
|
|
You can create your own constant that represents anything
you want. The safest technique of using a constant is to give a name. This
allows you to manage it from one standpoint. For example, if you plan to use a
number such as 3.14 that represents PI, you can simply use the constant 3.14.
Imagine you want to use 3.14 in various sections of the program. If you decide
to change the number from 3.14 to 3.14159 or another value, you would have to
find every mention of 3.14; this can be cumbersome and considered bad
programming. The alternative is to create a variable and assign it the desired
value. That new and defined value is called a constant.
To create a constant, you use the const keyword. The
simplest way you can do this is to type the const keyword followed by a name,
followed by =, followed by the desired value, and terminated by a semi colon.
Here is an example:
const NumberOfDoors = 4;
After creating such a constant, you can display its value
using the cout extractor:
//---------------------------------------------------------------------------
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
const NumberOfDoors = 4;
cout << "Number of doors = " << NumberOfDoors;
cout << "\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
This would produce:
Number of doors = 4
You can also involve such a constant in an operation as we
will learn in the next lesson.
When creating a constant as done above, the compiler assumes
that the constant is of type integer. If you initialize it to a value that is
not an integer, the compiler would try to convert it into an integer. Consider
the following example:
//---------------------------------------------------------------------------
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
const NumberOfDoors = 125.558;
cout << "Number of doors = " << NumberOfDoors;
cout << "\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
This would produce:
Number of doors = 125
The safest way to initialize a constant is to specify the
type of data of that constant. To do this, you enter the data type between the
const keyword and the name of the constant. Here is an example:
const double NumberOfValues = 125.558;
const long double Population = 258994;
const unsigned short int Alley = 88;
If you already know (and have included) a constant, you can
initialize your new constant with it. Here is an example:
//---------------------------------------------------------------------------
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
const double NumberOfValues = 125.558;
const long double Population = 258994;
const unsigned short int Alley = 88;
const double Root = NumberOfValues;
cout << "Constants";
cout << "\nValues: " << Root;
cout << "\nPopulation: " << Population;
cout << "\nAlley Val: " << Alley;
cout << "\nRoot Value: " << NumberOfValues;
cout << "\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
The C language provides a preprocessor used to create
macros. A macro is an action you want the compiler to perform for your program.
The particularity of macros, or most macros, is that the compiler counts on you
to know what you are doing. Many of such macros are created using the #define
preprocessor.
Based on this concept of macros, you can create a constant.
The formula of creating a constant using the define keyword is:
#define ConstantName ConstantValue
The # symbol and the define keyword are
required; they inform the compiler to consider that the following name
represents a constant.
The ConstantName represents a valid name for the
desired constant; the name follows the same rules we learned for defining names
in C++. To distinguish the constant from other names of variables, it is
sometimes a good idea to write it in uppercase, although it is perfectly normal
to have it in lowercase or any case combination you desire.
The ConstantValue can be a character, an integer, a
floating-point value, or an expression. If the constant value is an integer or a
floating-point value, you can type it. If the value is a character, include it
between single-quotes. If the constant value is a string, include it between
double-quotes. The definition of the constant does not end with a semi-colon.
Examples of declaring constants are:
#define AGE 12 // AGE represents the constant integer 12
#define ANSWER ‘y’
#define MAXSTUDENTS 35
#define And "&&"
#define PI 3.14159 // PI represents 3.14159
#define Country = “New Zealand”;
|
As you can see, there is no precision as to what type of
constant you are creating when using #define. The truth is that #define
doesn't create a constant. It is simply telling the compiler that the word after
#define will be used to represent whatever follows that ConstantName.
This means that, in reality, what follows ConstantName can be anything;
it can even be an expression. here is an expression:
//---------------------------------------------------------------------------
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
#define Add255To1250 255 + 1250
cout << "Addition: " << Add255To1250;
cout << "\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
In reality, the #define technique was implemented in
the C language and C++, as a child of C, simply inherited it from its parent.
The #define routine is still supported and you will encounter it in many
documents. In fact, you are not necessarily discouraged from using it but the
golden rule is to know what you are doing.
Operating System and Compiler Constants
|
|
Because constants are highly used in mathematics and other
scenarios, both the C++ language and the Borland C++ Builder compiler are
equipped with various constants. Although you can create your own constants
anytime, you should be aware of these constants and usually use them instead of
creating new ones, unless yours are more reliable.
Some of the constants that are part of the C++ language are
defined in the _lim.h library. Other constants are defined in various
other files such as windows.h, System.hpp, SysUtils.hpp, math.hpp,
etc. For example, the minimum value of the short integer is SHRT_MIN;
in the same way, the maximum short integer is identified by SHRT_MAX.
You can use either of these constants as follows:
//---------------------------------------------------------------------------
#include <vcl.h>
#include <iostream.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
cout << "The minimum short integer is: " << SHRT_MIN << "\n";
cout << "The maximum short integer is: " << SHRT_MAX << "\n";
cout << "\nPress any key to continue...";
getchar();
return 0;
}
//---------------------------------------------------------------------------
|
The integral constants are defined in the _lim.h library.
Practical Learning: Using Compiler Constants
|
|
- To view the list of constant integers, open Windows Explorer.
- Display the content of the C:\Program Files\Borland\Cbuilder\Include
folder
- Double-click the _lim.h file to open it.
Since you get the last way, I will not provide.
A namespace is a section of code, delimited and referred to
using a specific name. A namespace is created to set apart a portion of code
with the goal of reducing, otherwise eliminating, confusion. This is done by
giving a common name to that portion of code so that, when referring to it, only
entities that are part of that section would be referred to.
|
A namespace is not a variable. It is not
a constant. It is not a class. And it is not a file. It is simply a name
used to refer to a section of code. |
The syntax of creating a name space is:
namespace Name { Body }
The creation of a namespace starts with the (required)
namespace keyword followed by a name that would identify the section of code.
The name follows the rules we have been applying to C++ names. A namespace
contains a body; this is where the entities that are part of the namespace would
be declared or defined. The body of the namespace starts with an opening curly
bracket “{” and ends with a closing curly bracket “}”. Here is an
example of a simple namespace:
namespace Mine
{
int a;
}
|
The entities included in the body of a namespace are referred to as its
members.
Using the Scope Access Operator
|
|
To access a member of a namespace, there are various
techniques you can use. The scope access operator “::” used for classes is
the same you can use here. To do this, type the name of the namespace, followed
by the scope access operator “::”, followed by the member you are want to
access. Only the members of a particular namespace are available when using its
name. For example, to access the member “a” of the Mine namespace above, you
can write:
Mine::a;
Once you have access to a namespace member, you can
initialize it or display its value using the cout extractor operator. Here is an
example:
//---------------------------------------------------------------------------
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
namespace Mine
{
int a;
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
Mine::a = 140;
cout << "Value of a = " << Mine::a;
cout << "\n\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
This would produce:
Value of a = 140
Press any key to continue...
|
When creating a namespace, you can add as many members as you see fit. When
necessary, you can use the scope access operator to call anyone of them as
needed. Here is an example:
//---------------------------------------------------------------------------
#include <iostream.h>
#include <iomanip.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
namespace InterestAndDiscount
{
double Principal;
double Rate;
int Time;
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
InterestAndDiscount::Principal = 3250;
InterestAndDiscount::Rate = 14; // %
InterestAndDiscount::Time = 2;
cout << "Interest Calculation";
cout << setiosflags(ios::fixed) << setprecision(2);
cout << "\nPrincipal: $" << InterestAndDiscount::Principal;
cout << "\nRate: " << InterestAndDiscount::Rate << "%";
cout << "\nTime: " << InterestAndDiscount::Time << " years";
cout << "\n\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
You can also request the values of the members of a namespace from the user.
Here is an example:
//---------------------------------------------------------------------------
#include <iostream.h>
#include <iomanip.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
namespace InterestAndDiscount
{
double Principal;
double Rate;
int Time;
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
cout << "Interest and Discount\n";
cout << "Principal: $";
cin >> InterestAndDiscount::Principal;
cout << "Rate (between 0 and 100): ";
cin >> InterestAndDiscount::Rate;
cout << "Time (Nbr of Years): ";
cin >> InterestAndDiscount::Time;
cout << "\nInterest Calculation";
cout << setiosflags(ios::fixed) << setprecision(2);
cout << "\nPrincipal: $" << InterestAndDiscount::Principal;
cout << "\nRate: " << InterestAndDiscount::Rate << "%";
cout << "\nTime: " << InterestAndDiscount::Time << " years";
cout << "\n\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
Here is an example of running the program:
Interest and Discount
Principal: $12500
Rate (between 0 and 100): 7.25
Time (Nbr of Years): 10
Interest Calculation
Principal: $12500.00
Rate: 7.25%
Time: 10 years
Press any key to continue...
|
In the same way, you can manipulate the members of a namespace as your
application needs. They can be part of a conditional statement or the can be
involved in any type of arithmetic operation. Here is an example:
//---------------------------------------------------------------------------
#include <iostream.h>
#include <conio.h>
#include <iomanip.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
namespace InterestAndDiscount
{
double Principal;
double Rate;
int Time;
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
double Interest, Discount;
cout << "Interest and Discount\n";
cout << "Principal: $";
cin >> InterestAndDiscount::Principal;
cout << "Rate (between 0 and 100): ";
cin >> InterestAndDiscount::Rate;
cout << "Time (Nbr of Years): ";
cin >> InterestAndDiscount::Time;
Discount = InterestAndDiscount::Rate / 100;
Interest = InterestAndDiscount::Principal * Discount *
InterestAndDiscount::Time;
cout << "\nInterest Calculation";
cout << setiosflags(ios::fixed) << setprecision(2);
cout << "\nPrincipal: $" << InterestAndDiscount::Principal;
cout << "\nRate: " << InterestAndDiscount::Rate << "%";
cout << "\nTime: " << InterestAndDiscount::Time << " years";
cout << "\nInterest: $" << Interest;
cout << "\n\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
Here is an example of running the program:
Interest and Discount
Principal: $2500
Rate (between 0 and 100): 6.25
Time (Nbr of Years): 4
Interest Calculation
Principal: $2500.00
Rate: 6.25%
Time: 4 years
Interest: $625.00
Press any key to continue...
|
Practical Learning: Creating a Namespace
|
|
- Create a new C++ Console Application using the Console Wizard.
- Save the unit as Main in a new folder called Students1
- Save the project as Students
- To create a new namespace, change the Main.cpp
file as follows:
//---------------------------------------------------------------------------
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
//---------------------------------------------------------------------------
namespace Students
{
string FirstName;
string LastName;
char Gender;
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
Students::FirstName = "Laurentine";
Students::LastName = "Sachs";
Students::Gender = 'F';
cout << "Student Registration";
cout << "\nFull Name: "
<< Students::FirstName << " " << Students::LastName;
cout << "\nGender: " << Students::Gender;
cout << "\n\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
- To test the program, on the main menu, click Run -> Run:
Student Registration
Full Name: Laurentine Sachs
Gender: F
Press any key to continue...
|
- After testing the program, return to Bcb
- To request the values of the members of a namespace, change the main()
function as follows:
//---------------------------------------------------------------------------
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
//---------------------------------------------------------------------------
namespace Students
{
string FirstName;
string LastName;
char Gender;
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
cout << "Student Registration\n";
cout << "First Name: ";
cin >> Students::FirstName;
cout << "Last Name: ";
cin >> Students::LastName;
cout << "Gender (m=Male/f=Female): ";
cin >> Students::Gender;
Students::Gender = toupper(Student::Gender);
cout << "\nStudent Registration";
cout << "\nFull Name: "
<< Students::FirstName << " " << Students::LastName;
cout << "\nGender: " << Students::Gender;
cout << "\n\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
- Test the program and return to Bcb.
- To apply a conditional statement to a member of a namespace, change the
main() function as follows:
//---------------------------------------------------------------------------
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
//---------------------------------------------------------------------------
namespace Students
{
string FirstName;
string LastName;
char Gender;
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
cout << "Student Registration\n";
cout << "First Name: ";
cin >> Students::FirstName;
cout << "Last Name: ";
cin >> Students::LastName;
cout << "Gender (m=Male/f=Female): ";
cin >> Students::Gender;
Students::Gender = toupper(Students::Gender);
cout << "\nStudent Registration";
cout << "\nFull Name: "
<< Students::FirstName << " " << Students::LastName;
cout << "\nGender: ";
if( Students::Gender == 'M' )
cout << "Male";
else if( Students::Gender == 'F' )
cout << "Female";
else
cout << "Unspecified...";
cout << "\n\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
- Test the program. Here is an example:
Student Registration
First Name: Leslie
Last Name: Epps
Gender (m=Male/f=Female): d
Student Registration
Full Name: Leslie Epps
Gender: Unspecified...
Press any key to continue...
|
- Return to Bcb
- When using the scope access operator “::” to call members of a
namespace, each member has to be qualified with the operator. This reduces
confusion as to what variable you are referring to and also allows you to
use the same name in different parts of a program. For example, in a
function, you can have a local variable that holds the same name as a member
of a namespace. When calling such a variable, the “::” operator can set
apart what variable you are referring to. To demonstrate this, a Gender
variable is declared in both a name space and the main() function. The use
of the access operator helps to specify which Gender variable is called at
one time. To test it, change the main() function as follows:
//---------------------------------------------------------------------------
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
//---------------------------------------------------------------------------
namespace Students
{
string FirstName;
string LastName;
char Gender;
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
string Gender; // Local variable bearing the same name as above
cout << "Student Registration\n";
cout << "First Name: ";
cin >> Students::FirstName;
cout << "Last Name: ";
cin >> Students::LastName;
cout << "Gender (m=Male/f=Female): ";
cin >> Students::Gender;
Students::Gender = toupper(Students::Gender);
// Testing the value of a member of a namespace
if( Students::Gender == 'M' )
Gender = "Male"; // Initializing a local variable
else if( Students::Gender == 'F' )
Gender = "Female";
else
Gender = "Unspecified...";
cout << "\nStudent Information";
cout << "\nFull Name: "
<< Students::FirstName << " " << Students::LastName;
cout << "\nGender: " << Gender; // Displaying a local variable
cout << "\n\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
- Test the program. Here is an example:
Student Registration
First Name: Josiane
Last Name: Pugnol
Gender (m=Male/f=Female): f
Student Information
Full Name: Josiane Pugnol
Gender: Female
Press any key to continue...
|
- Return to Bcb
The scope access operator “::”provides a safe mechanism
to access the members of a namespace. If the namespace is very large and the
application needs constant access, this might be a little redundant. Another
technique used to access the members of a namespace involves using two keywords:
using and namespace.
To call a namespace, on the section of the program where you
need to access the members, type:
using namespace NamespaceName;
Both the using and the namespace keywords are required by
the compiler. The NamespaceName represents the name of the namespace
whose member(s) you want to access. Using this technique, the above program can
be written:
//---------------------------------------------------------------------------
#include <iostream.h>
#include <iomanip.h>
#include <conio.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
namespace InterestAndDiscount
{
double Principal;
double Rate;
int Time;
double Interest;
double Discount;
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
using namespace InterestAndDiscount;
double Interest, Discount;
cout << "Interest and Discount\n";
cout << "Principal: $";
cin >> Principal;
do {
cout << "Rate (between 0 and 100): ";
cin >> InterestAndDiscount::Rate;
} while(Rate < 0 && Rate > 100);
cout << "Time (Nbr of Years): ";
cin >> Time;
Discount = Rate / 100;
Interest = Principal * Discount * Time;
cout << "\nInterest Calculation";
cout << setiosflags(ios::fixed) << setprecision(2);
cout << "\nPrincipal: $" << Principal;
cout << "\nRate: " << Rate << "%";
cout << "\nTime: " << Time << " years";
cout << "\nInterest: $" << Interest;
cout << "\n\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
This would produce:
Interest and Discount
Principal: $2500
Rate (between 0 and 100): 5.55
Time (Nbr of Years): 6
Interest Calculation
Principal: $2500.00
Rate: 5.55%
Time: 6 years
Interest: $832.50
Press any key to continue...
|
In a mixed environment (we are still inside of one function
only) where a local variable holds the same name as the member of a namespace
that is being accessed with the using namespace routine, you will be sensitive
to the calling of the same name variable. When manipulating such a name of a
variable that is present locally in the function as well as in the namespace
that is being accessed, the compiler will require more precision from you. You
will need to specify what name is being called.
Practical Learning: The using namespace Keywords
|
|
- To use the using and namespace keywords, change the main() function as
follows:
//---------------------------------------------------------------------------
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
//---------------------------------------------------------------------------
namespace Students
{
string FirstName;
string LastName;
char Gender;
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
using namespace Students;
cout << "Student Registration\n";
cout << "First Name: ";
cin >> FirstName;
cout << "Last Name: ";
cin >> LastName;
cout << "Gender (m=Male/f=Female): ";
cin >> Gender;
Gender = toupper(Gender);
cout << "\nStudent Information";
cout << "\nFull Name: "
<< FirstName << " " << LastName;
cout << "\nGender: ";
if( Gender == 'M' )
cout << "Male";
else if( Gender == 'F' )
cout << "Female";
else
cout << "Unspecified...";
cout << "\n\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
- Test the program. Here is an example:
Student Registration
First Name: Gabrielle
Last Name: Ledoux
Gender (m=Male/f=Female): f
Student Information
Full Name: Gabrielle Ledoux
Gender: Female
Press any key to continue...
|
- Return to Bcb
- To declare a variable that holds the same name as a member of a namespace,
change the main() function as follows:
//---------------------------------------------------------------------------
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
//---------------------------------------------------------------------------
namespace Students
{
string FirstName;
string LastName;
char Gender;
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
string Gender;
using namespace Students;
cout << "Student Registration\n";
cout << "First Name: ";
cin >> FirstName;
cout << "Last Name: ";
cin >> LastName;
cout << "Gender (m=Male/f=Female): ";
cin >> Gender;
cout << "\nStudent Information";
cout << "\nFull Name: "
<< FirstName << " " << LastName;
cout << "\nGender: " << Gender;
cout << "\n\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
- Test the program. When asked for the Gender, type m or f and press Enter
- Return to Bcb and test the program again. This time, for the Gender, type
Male or Female and press Enter. Return to Bcb
- To simulate a confusing scenario for namespace and local variables, change
the main() function as follows (look at the comments):
//---------------------------------------------------------------------------
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
//---------------------------------------------------------------------------
namespace Students
{
string FirstName;
string LastName;
char Gender;
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
string Gender;
using namespace Students;
cout << "Student Registration\n";
cout << "First Name: ";
cin >> FirstName;
cout << "Last Name: ";
cin >> LastName;
cout << "Gender (m=Male/f=Female): ";
// What variable are you requesting? The local Gender or Student::Gender?
cin >> Gender;
// What variable is being compared? The local Gender or Student::Gender?
if( Gender == 'm' || Gender == 'M' )
Gender = "Male";
else if( Gender == 'f' || Gender == 'F' )
Gender = "Female";
else
Gender = "Unspecified...";
cout << "\nStudent Information";
cout << "\nFull Name: " << FirstName << " " << LastName;
cout << "\nGender: " << Gender;
cout << "\n\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
- Test the program. It would not compile
- There are many solutions you can use to resolve this issue. The best and
safest technique is to use different names; that is, when declaring your
variables, use names that are not part of the namespace you are trying to
access. The problem is that it is very unrealistic to know all names that
are used by C++, by the operating system, and by the Visual Component
Library. The other solution is to qualify the member of a namespace whenever
you call it. Therefore change the above program as follows:
//---------------------------------------------------------------------------
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
//---------------------------------------------------------------------------
namespace Students
{
string FirstName;
string LastName;
char Gender;
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
string Gender;
using namespace Students;
cout << "Student Registration\n";
cout << "First Name: ";
cin >> FirstName;
cout << "Last Name: ";
cin >> LastName;
cout << "Gender (m=Male/f=Female): ";
// Once again, are we requesting the local Gender or Student::Gender?
// Because the Gender belongs to the Student Registration, let's
// request the Student::Gender value
cin >> Students::Gender;
// Since we requested the Student::Gender and not the local Gender,
// We will perform the comparison on that value
if( Students::Gender == 'm' || Students::Gender == 'M' )
Gender = "Male";
else if( Students::Gender == 'f' || Students::Gender == 'F' )
Gender = "Female";
else
Gender = "Unspecified...";
cout << "\nStudent Information";
cout << "\nFull Name: " << FirstName << " " << LastName;
// We are locally displaying the Gender. Therefore, we will call it
cout << "\nGender: " << Gender;
cout << "\n\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
- Test the program and return to Bcb.
Various namespaces can be part of the same file and the same
application. You can create each namespace and specify its own members in its
delimiting curly brackets. With various namespaces on the same file or
application, you can have the same variables in different namespaces. Here is an
example of two namespaces:
//---------------------------------------------------------------------------
namespace InterestAndDiscount
{
double Principal;
double Rate;
int Time;
double Interest;
double Discount;
}
//---------------------------------------------------------------------------
namespace BuyAndSell
{
double OriginalPrice;
double TaxRate;
double TaxAmount;
double Discount;
double DiscountAmount;
double NetPrice;
}
//---------------------------------------------------------------------------
|
To access the member of a namespace, use the scope access
operator appended to its name and call the desired member. Here is an example:
//---------------------------------------------------------------------------
#include <iostream.h>
#include <iomanip.h>
#include <conio.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
//---------------------------------------------------------------------------
namespace InterestAndDiscount
{
double Principal;
double Rate;
int Time;
double Interest;
double Discount;
}
//---------------------------------------------------------------------------
namespace BuyAndSell
{
double OriginalPrice;
double TaxRate;
double TaxAmount;
double Discount;
double DiscountAmount;
double NetPrice;
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
InterestAndDiscount::Principal = 14500; // $
InterestAndDiscount::Rate = 12.52; // %
InterestAndDiscount::Time = 2; // Years
InterestAndDiscount::Discount = InterestAndDiscount::Rate / 100;
InterestAndDiscount::Interest = InterestAndDiscount::Principal *
InterestAndDiscount::Discount *
InterestAndDiscount::Time;
cout << "Interest Calculation";
cout << setiosflags(ios::fixed) << setprecision(2);
cout << "\nPrincipal: " << setw(4) << "$"
<< InterestAndDiscount::Principal
<< "\nRate: " << setw(17) << InterestAndDiscount::Rate << "%"
<< "\nDiscount: " << setw(9) << "$"
<< InterestAndDiscount::Discount
<< "\nTime: " << setw(14) << InterestAndDiscount::Time << " years"
<< "\nInterest: " << setw(6) << "$"
<< InterestAndDiscount::Interest;
BuyAndSell::OriginalPrice = 350; // $
BuyAndSell::TaxRate = 5.75; // %
BuyAndSell::Discount = 20; // %
BuyAndSell::TaxAmount = BuyAndSell::OriginalPrice *
BuyAndSell::TaxRate / 100;
BuyAndSell::DiscountAmount = BuyAndSell::OriginalPrice *
BuyAndSell::Discount / 100;
BuyAndSell::NetPrice = BuyAndSell::OriginalPrice +
BuyAndSell::TaxAmount -
BuyAndSell::DiscountAmount;
cout << "\n\nBuy and Sell - Receipt";
cout << "\nOriginal Price: " << setw(1) << "$"
<< BuyAndSell::OriginalPrice
<< "\nDiscount: " << setw(8) << "$" << BuyAndSell::DiscountAmount
<< "\nTax Rate: " << setw(13) << BuyAndSell::TaxRate
<< "\nTax Amount: " << setw(6) << "$" << BuyAndSell::TaxAmount
<< "\nNet Price: " << setw(6) << "$" << BuyAndSell::NetPrice;
cout << "\n\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
Using the scope access operator like that, you can perform
any operation on any member of one namespace applied to a member of another
namespace.
We saw earlier that the using namespace routine allows
accessing the members of a namespace. This technique is based on the scope of
the routine. After typing it, if the name of a variable appears under a using
namespace, the compiler would need to reconcile or identify it; if the name of
such a variable is not recognized as part of the namespace that is being
accessed, the program would not compile. For example, here is an example that
uses two using namespace routines:
//---------------------------------------------------------------------------
#include <iostream.h>
#include <iomanip.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
//---------------------------------------------------------------------------
namespace InterestAndDiscount
{
double Principal;
double Rate;
int Time;
double Interest;
double Discount;
}
//---------------------------------------------------------------------------
namespace BuyAndSell
{
double OriginalPrice;
double TaxRate;
double TaxAmount;
double Discount;
double DiscountAmount;
double NetPrice;
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
using namespace InterestAndDiscount;
Principal = 14500; // $
Rate = 12.52; // %
Time = 2; // Years
Discount = Rate / 100;
Interest = Principal * Discount * Time;
cout << "Interest Calculation";
cout << setiosflags(ios::fixed) << setprecision(2);
cout << "\nPrincipal: " << setw(4) << "$" << Principal
<< "\nRate: " << setw(17) << Rate << "%"
<< "\nDiscount: " << setw(9) << "$" << Discount
<< "\nTime: " << setw(14) << Time << " years"
<< "\nInterest: " << setw(6) << "$" << Interest;
using namespace BuyAndSell;
OriginalPrice = 350; // $
TaxRate = 5.75; // %
Discount = 20; // %
TaxAmount = OriginalPrice * TaxRate / 100;
DiscountAmount = OriginalPrice * Discount / 100;
NetPrice = OriginalPrice + TaxAmount - DiscountAmount;
cout << "\n\nBuy and Sell - Receipt";
cout << "\nOriginal Price: " << setw(1) << "$" << OriginalPrice
<< "\nDiscount: " << setw(8) << "$" << DiscountAmount
<< "\nTax Rate: " << setw(13) << TaxRate
<< "\nTax Amount: " << setw(6) << "$" << TaxAmount
<< "\nNet Price: " << setw(6) << "$" << NetPrice;
cout << "\n\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
The above program would not compile because the compiler
does not understand what Discount is being referred to in the second Discount
call: is it InterestAndDiscount::Discount or BuyAndSell::Discount?
If you want to use different namespaces with the using
namespace routine, each namespace will have to control its scope. One
solution would be to create a “physical” scope for each namespace. Here is
an example:
//---------------------------------------------------------------------------
#include <iostream.h>
#include <iomanip.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
//---------------------------------------------------------------------------
namespace InterestAndDiscount
{
double Principal;
double Rate;
int Time;
double Interest;
double Discount;
}
//---------------------------------------------------------------------------
namespace BuyAndSell
{
double OriginalPrice;
double TaxRate;
double TaxAmount;
double Discount;
double DiscountAmount;
double NetPrice;
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
{
using namespace InterestAndDiscount;
Principal = 14500; // $
Rate = 12.52; // %
Time = 2; // Years
Discount = Rate / 100;
Interest = Principal * Discount * Time;
cout << "Interest Calculation";
cout << setiosflags(ios::fixed) << setprecision(2);
cout << "\nPrincipal: " << setw(4) << "$" << Principal
<< "\nRate: " << setw(17) << Rate << "%"
<< "\nDiscount: " << setw(9) << "$" << Discount
<< "\nTime: " << setw(14) << Time << " years"
<< "\nInterest: " << setw(6) << "$" << Interest;
}
// The scope of the above namespace has been closed
// So we don't have to create a new scope for the following namespace
// Since it is the only namespace now, it can control the rest
// If there was another namespace that shares a similar variable,
// we would have to create another scope
using namespace BuyAndSell;
OriginalPrice = 350; // $
TaxRate = 5.75; // %
Discount = 20; // %
TaxAmount = OriginalPrice * TaxRate / 100;
DiscountAmount = OriginalPrice * Discount / 100;
NetPrice = OriginalPrice + TaxAmount - DiscountAmount;
cout << "\n\nBuy and Sell - Receipt";
cout << "\nOriginal Price: " << setw(1) << "$" << OriginalPrice
<< "\nDiscount: " << setw(8) << "$" << DiscountAmount
<< "\nTax Rate: " << setw(13) << TaxRate
<< "\nTax Amount: " << setw(6) << "$" << TaxAmount
<< "\nNet Price: " << setw(6) << "$" << NetPrice;
cout << "\n\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
Before creating a “physical” scope, we saw that the
compiler is able to point out what problem occurred at compilation time.
Fortunately, the compiler is able to explicitly designate what problem it
encountered. In this case there is a conflict in name resolution: two namespaces
have a member of the same name.
The solution, which is commonly used, is to qualify the
variable that is causing the conflict. You can qualify only the second Discount
call because the compiler will associate the first Discount call with the first
using namespace. The safest way is to qualify both calls to the Discount
variable, as follows:
//---------------------------------------------------------------------------
#include <iostream.h>
#include <iomanip.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
//---------------------------------------------------------------------------
namespace InterestAndDiscount
{
double Principal;
double Rate;
int Time;
double Interest;
double Discount;
}
//---------------------------------------------------------------------------
namespace BuyAndSell
{
double OriginalPrice;
double TaxRate;
double TaxAmount;
double Discount;
double DiscountAmount;
double NetPrice;
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
using namespace InterestAndDiscount;
Principal = 14500; // $
Rate = 12.52; // %
Time = 2; // Years
InterestAndDiscount::Discount = Rate / 100;
Interest = Principal * InterestAndDiscount::Discount * Time;
cout << "Interest Calculation";
cout << setiosflags(ios::fixed) << setprecision(2);
cout << "\nPrincipal: " << setw(4) << "$" << Principal
<< "\nRate: " << setw(17) << Rate << "%"
<< "\nDiscount: " << setw(9) << "$" << InterestAndDiscount::Discount
<< "\nTime: " << setw(14) << Time << " years"
<< "\nInterest: " << setw(6) << "$" << Interest;
// The scope of the above namespace has been closed
// So we don't have to create a new scope for the following namespace
// Since it is the only namespace now, it can control the rest
// If there was another namespace that shares a similar variable,
// we would have to create another scope
using namespace BuyAndSell;
OriginalPrice = 350; // $
TaxRate = 5.75; // %
BuyAndSell::Discount = 20; // %
TaxAmount = OriginalPrice * TaxRate / 100;
DiscountAmount = OriginalPrice * BuyAndSell::Discount / 100;
NetPrice = OriginalPrice + TaxAmount - DiscountAmount;
cout << "\n\nBuy and Sell - Receipt";
cout << "\nOriginal Price: " << setw(1) << "$" << OriginalPrice
<< "\nDiscount: " << setw(8) << "$" << DiscountAmount
<< "\nTax Rate: " << setw(13) << TaxRate
<< "\nTax Amount: " << setw(6) << "$" << TaxAmount
<< "\nNet Price: " << setw(6) << "$" << NetPrice;
cout << "\n\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
Practical Learning: Using Various Namespaces
|
|
- To use various namespaces, change the file as follows:
//---------------------------------------------------------------------------
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
//---------------------------------------------------------------------------
namespace Students
{
string FirstName;
string LastName;
char Gender;
}
namespace StaffMembers
{
string FirstName;
string LastName;
char MaritalStatus;
double Salary;
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
using namespace Students;
using namespace StaffMembers;
cout << "Process Student Registration\n";
cout << "First Name: "; cin >> Students::FirstName;
cout << "Last Name: "; cin >> Students::LastName;
cout << "Gender (m=Male/f=Female): "; cin >> Gender;
cout << "\nEnter information about the employee\n";
cout << "First Name: "; cin >> StaffMembers::FirstName;
cout << "Last Name: "; cin >> StaffMembers::LastName;
cout << "Married (1=Yes/0=No)? ";
cin >> MaritalStatus;
cout << "Hourly Salary: $"; cin >> Salary;
cout << "\n - Student Information -";
cout << "\nFull Name: " << Students::FirstName
<< " " << Students::LastName;
cout << "\nGender: ";
if( Gender == 'm' || Gender == 'M' )
cout << "Male\n";
else if( Gender == 'f' || Gender == 'F' )
cout << "Female\n";
else
cout << "Unspecified...\n";
cout << "\n - Staff Member Information -";
cout << "\nFull Name: " << StaffMembers::LastName << ", "
<< StaffMembers::FirstName;
cout << "\nMarital Status: ";
if( MaritalStatus == '1' )
cout << "Married";
else
cout << "Not Married";
cout << "\nHourly Salary: $" << Salary << endl;
cout << "\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
- Test the application. Here is an example:
Process Student Registration
First Name: Valentin
Last Name: Nguyen
Gender (m=Male/f=Female): M
Enter information about the employee
First Name: Laurentine
Last Name: Sachs
Married (1=Yes/0=No)? 6
Hourly Salary: $15.58
- Student Information -
Full Name: Valentin Nguyen
Gender: Male
- Staff Member Information -
Full Name: Sachs, Laurentine
Marital Status: Not Married
Hourly Salary: $15.58
Press any key to continue...
|
- Return to Bcb
Nesting a namespace is the ability to include a namespace
inside (as part of the body) of another namespace. To do this, create the
intended namespace as a member of the parent namespace. The nested namespace
should have its own name and its own body. Here is an example:
//---------------------------------------------------------------------------
namespace BuyAndSell
{
double OriginalPrice;
double TaxRate;
double TaxAmount;
double Discount;
double DiscountAmount;
double NetPrice;
namespace ItemID
{
long ItemNumber;
string Manufacturer;
string ItemCategory;
}
}
//---------------------------------------------------------------------------
|
To access a member of a nested namespace, first call its
parent, type the :: operator, type the name of the nested namespace, followed by
the :: operator, then type the name of the variable you are trying to access.
Here is an example:
//---------------------------------------------------------------------------
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
namespace BuyAndSell
{
double OriginalPrice;
double TaxRate;
double TaxAmount;
double Discount;
double DiscountAmount;
double NetPrice;
namespace ItemID
{
long ItemNumber;
string Manufacturer;
string ItemCategory;
}
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
BuyAndSell::OriginalPrice = 34.95;
BuyAndSell::TaxRate = 7.55;
BuyAndSell::Discount = 5;
BuyAndSell::ItemID::ItemNumber = 641238;
BuyAndSell::ItemID::Manufacturer = "Haring Clothing, Inc.";
BuyAndSell::ItemID::ItemCategory = "Men's Apparel";
BuyAndSell::TaxAmount = BuyAndSell::OriginalPrice *
BuyAndSell::TaxRate / 100;
BuyAndSell::DiscountAmount = BuyAndSell::OriginalPrice *
BuyAndSell::Discount / 100;
BuyAndSell::NetPrice = BuyAndSell::OriginalPrice +
BuyAndSell::TaxAmount -
BuyAndSell::DiscountAmount;
cout << "Buy and Sell - Receipt";
cout << "\nItem Nunmber: " << BuyAndSell::ItemID::ItemNumber;
cout << "\nManufacturer: " << BuyAndSell::ItemID::Manufacturer;
cout << "\nItem Category: " << BuyAndSell::ItemID::ItemCategory;
cout << "\nOriginal Price: $" << BuyAndSell::OriginalPrice;
cout << "\nDiscount: $" << BuyAndSell::DiscountAmount;
cout << "\nTax Rate: " << BuyAndSell::TaxRate;
cout << "\nTax Amount $" << BuyAndSell::TaxAmount;
cout << "\nNet Price: $" << BuyAndSell::NetPrice;
cout << "\n\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
Following the same logic, you can have as many namespaces
and many nested namespaces in your application as you desire. If you nest a
namespace, you can use as many :: operators to qualify each member of the nested
namespace you want. Here is an example:
//---------------------------------------------------------------------------
#include <iostream.h>
#include <iomanip.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
namespace InterestAndDiscount
{
double Principal;
double Rate;
int Time;
double Interest;
double Discount;
namespace ItemIdentifier
{
long ItemNumber;
string DateAcquired;
namespace ItemType
{
int ItemCategory;
string Manufacturer;
string Model;
}
}
}
//---------------------------------------------------------------------------
namespace BuyAndSell
{
double OriginalPrice;
double TaxRate;
double TaxAmount;
double Discount;
double DiscountAmount;
double NetPrice;
namespace ItemID
{
long ItemNumber;
string Manufacturer;
string ItemCategory;
}
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
InterestAndDiscount::Principal = 18450; // $
InterestAndDiscount::Rate = 14.75; // %
InterestAndDiscount::Time = 4; // Years
InterestAndDiscount::Discount = InterestAndDiscount::Rate / 100;
InterestAndDiscount::Interest = InterestAndDiscount::Principal *
InterestAndDiscount::Discount *
InterestAndDiscount::Time;
InterestAndDiscount::ItemIdentifier::ItemNumber = 787343;
InterestAndDiscount::ItemIdentifier::DateAcquired = "10/5/2000";
InterestAndDiscount::ItemIdentifier::ItemType::ItemCategory = 1;
InterestAndDiscount::ItemIdentifier::ItemType::Manufacturer = "Honda";
InterestAndDiscount::ItemIdentifier::ItemType::Model = "Accord";
cout << setiosflags(ios::fixed) << setprecision(2);
cout << "Processing Item";
cout << "\nStore Number: " << setw(7)
<< InterestAndDiscount::ItemIdentifier::ItemNumber;
cout << "\nDate Acquired: " << setw(4)
<< InterestAndDiscount::ItemIdentifier::DateAcquired;
cout << "\nCategory: " << setw(6)
<< InterestAndDiscount::ItemIdentifier::ItemType::ItemCategory;
cout << "\nManufacturer: " << setw(6)
<< InterestAndDiscount::ItemIdentifier::ItemType::Manufacturer;
cout << "\nModel: " << setw(14)
<< InterestAndDiscount::ItemIdentifier::ItemType::Model;
cout << "\nPrincipal: " << setw(4) << "$"
<< InterestAndDiscount::Principal;
cout << "\nRate: " << setw(17)
<< InterestAndDiscount::Rate << "%";
cout << "\nDiscount: " << setw(9) << "$"
<< InterestAndDiscount::Discount;
cout << "\nTime: " << setw(10)
<< InterestAndDiscount::Time << " years";
cout << "\nInterest: " << setw(5) << "$"
<< InterestAndDiscount::Interest;
BuyAndSell::OriginalPrice = 34.95;
BuyAndSell::TaxRate = 7.55;
BuyAndSell::Discount = 5;
BuyAndSell::ItemID::ItemNumber = 641238;
BuyAndSell::ItemID::Manufacturer = "Haring Clothing, Inc.";
BuyAndSell::ItemID::ItemCategory = "Men's Apparel";
BuyAndSell::TaxAmount = BuyAndSell::OriginalPrice *
BuyAndSell::TaxRate / 100;
BuyAndSell::DiscountAmount = BuyAndSell::OriginalPrice *
BuyAndSell::Discount / 100;
BuyAndSell::NetPrice = BuyAndSell::OriginalPrice +
BuyAndSell::TaxAmount -
BuyAndSell::DiscountAmount;
cout << "\n\nBuy and Sell - Receipt";
cout << "\nItem Number: " << setw(8)
<< BuyAndSell::ItemID::ItemNumber;
cout << "\nManufacturer: " << setw(14)
<< BuyAndSell::ItemID::Manufacturer;
cout << "\nItem Category: " << setw(10)
<< BuyAndSell::ItemID::ItemCategory;
cout << "\nOriginal Price: " << setw(1) << "$"
<< BuyAndSell::OriginalPrice;
cout << "\nDiscount: " << setw(8) << "$"
<< BuyAndSell::DiscountAmount;
cout << "\nTax Rate: " << setw(12) << BuyAndSell::TaxRate;
cout << "\nTax Amount " << setw(7)
<< "$" << BuyAndSell::TaxAmount;
cout << "\nNet Price: " << setw(6)
<< "$" << BuyAndSell::NetPrice;
cout << "\n\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
This would produce:
Processing Item
Store Number: 787343
Date Acquired: 10/5/2000
Category: 1
Manufacturer: Honda
Model: Accord
Principal: $18450.00
Rate: 14.75%
Discount: $0.15
Time: 4 years
Interest: $10885.50
Buy and Sell - Receipt
Item Number: 641238
Manufacturer: Haring Clothing, Inc.
Item Category: Men's Apparel
Original Price: $34.95
Discount: $1.75
Tax Rate: 7.55
Tax Amount $2.64
Net Price: $35.84
Press any key to continue...
|
You can also use the using namespace routine by
qualifying each member inside the using namespace that “needs” its parent:
//---------------------------------------------------------------------------
#include <iostream.h>
#include <iomanip.h>
#include <conio.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
namespace InterestAndDiscount
{
double Principal;
double Rate;
int Time;
double Interest;
double Discount;
namespace ItemIdentifier
{
long ItemNumber;
string DateAcquired;
namespace ItemType
{
int ItemCategory;
string Manufacturer;
string Model;
}
}
}
//---------------------------------------------------------------------------
namespace BuyAndSell
{
double OriginalPrice;
double TaxRate;
double TaxAmount;
double Discount;
double DiscountAmount;
double NetPrice;
namespace ItemID
{
long ItemNumber;
string Manufacturer;
string ItemCategory;
}
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
using namespace InterestAndDiscount;
Principal = 18450; // $
Rate = 14.75; // %
Time = 4; // Years
Discount = Rate / 100;
Interest = Principal * Discount * Time;
ItemIdentifier::ItemNumber = 787343;
ItemIdentifier::DateAcquired = "10/5/2000";
ItemIdentifier::ItemType::ItemCategory = 1;
ItemIdentifier::ItemType::Manufacturer = "Honda";
ItemIdentifier::ItemType::Model = "Accord";
cout << setiosflags(ios::fixed) << setprecision(2);
cout << "Processing Item";
cout << "\nStore Number: " << setw(7)
<< ItemIdentifier::ItemNumber;
cout << "\nDate Acquired: " << setw(4)
<< ItemIdentifier::DateAcquired;
cout << "\nCategory: " << setw(6)
<< ItemIdentifier::ItemType::ItemCategory;
cout << "\nManufacturer: " << setw(6)
<< ItemIdentifier::ItemType::Manufacturer;
cout << "\nModel: " << setw(14)
<< ItemIdentifier::ItemType::Model;
cout << "\nPrincipal: " << setw(4) << "$" << Principal;
cout << "\nRate: " << setw(17) << Rate << "%";
cout << "\nDiscount: " << setw(9) << "$"
<< InterestAndDiscount::Discount;
cout << "\nTime: " << setw(10) << Time << " years";
cout << "\nInterest: " << setw(5) << "$" << Interest;
using namespace BuyAndSell;
OriginalPrice = 34.95;
TaxRate = 7.55;
BuyAndSell::Discount = 5;
ItemID::ItemNumber = 641238;
ItemID::Manufacturer = "Haring Clothing, Inc.";
ItemID::ItemCategory = "Men's Apparel";
TaxAmount = OriginalPrice * TaxRate / 100;
DiscountAmount = OriginalPrice * BuyAndSell::Discount / 100;
NetPrice = OriginalPrice + TaxAmount - DiscountAmount;
cout << "\n\nBuy and Sell - Receipt";
cout << "\nItem Nunmber: " << setw(8) << ItemID::ItemNumber;
cout << "\nManufacturer: " << setw(14) << ItemID::Manufacturer;
cout << "\nItem Category: " << setw(10) << ItemID::ItemCategory;
cout << "\nOriginal Price: " << setw(1) << "$" << OriginalPrice;
cout << "\nDiscount: " << setw(8) << "$" << DiscountAmount;
cout << "\nTax Rate: " << setw(12) << TaxRate;
cout << "\nTax Amount " << setw(7) << "$" << TaxAmount;
cout << "\nNet Price: " << setw(6) << "$" << NetPrice;
cout << "\n\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
Otherwise, you can create a using namespace for each
namespace and make sure that each one of them controls its scope. As long as you
are using the scope access operator to identify the variable that is being
accessed inside of a using namespace, you can call the member of any namespace
in any scope, provided you qualify it.
When a namespace is nested, a first using namespace can be
used to nvoque the parent namespace. You can use a scope access operator
“::” with a using namespace to further refine the members of a sub-namespace
as follows:
//---------------------------------------------------------------------------
#include <iostream.h>
#include <iomanip.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
namespace InterestAndDiscount
{
double Principal;
double Rate;
int Time;
double Interest;
double Discount;
namespace ItemIdentifier
{
long ItemNumber;
string DateAcquired;
namespace ItemType
{
int ItemCategory;
string Manufacturer;
string Model;
}
}
}
//---------------------------------------------------------------------------
namespace BuyAndSell
{
double OriginalPrice;
double TaxRate;
double TaxAmount;
double Discount;
double DiscountAmount;
double NetPrice;
namespace ItemID
{
long ItemNumber;
string Manufacturer;
string ItemCategory;
}
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
using namespace InterestAndDiscount;
Principal = 18450; // $
Rate = 14.75; // %
Time = 4; // Years
Discount = Rate / 100;
Interest = Principal * Discount * Time;
using namespace InterestAndDiscount::ItemIdentifier;
ItemNumber = 787343;
DateAcquired = "10/5/2000";
ItemType::ItemCategory = 1;
ItemType::Manufacturer = "Honda";
ItemType::Model = "Accord";
cout << setiosflags(ios::fixed) << setprecision(2);
cout << "Processing Item";
cout << "\nStore Number: " << setw(7)
<< ItemNumber;
cout << "\nDate Acquired: " << setw(4)
<< DateAcquired;
cout << "\nCategory: " << setw(6)
<< ItemType::ItemCategory;
cout << "\nManufacturer: " << setw(6)
<< ItemType::Manufacturer;
cout << "\nModel: " << setw(14)
<< ItemType::Model;
cout << "\nPrincipal: " << setw(4) << "$" << Principal;
cout << "\nRate: " << setw(17) << Rate << "%";
cout << "\nDiscount: " << setw(9) << "$"
<< InterestAndDiscount::Discount;
cout << "\nTime: " << setw(10) << Time << " years";
cout << "\nInterest: " << setw(5) << "$" << Interest;
using namespace BuyAndSell;
OriginalPrice = 34.95;
TaxRate = 7.55;
BuyAndSell::Discount = 5;
ItemID::ItemNumber = 641238;
ItemID::Manufacturer = "Haring Clothing, Inc.";
ItemID::ItemCategory = "Men's Apparel";
TaxAmount = OriginalPrice * TaxRate / 100;
DiscountAmount = OriginalPrice * BuyAndSell::Discount / 100;
NetPrice = OriginalPrice + TaxAmount - DiscountAmount;
cout << "\n\nBuy and Sell - Receipt";
cout << "\nItem Nunmber: " << setw(8) << ItemID::ItemNumber;
cout << "\nManufacturer: " << setw(14) << ItemID::Manufacturer;
cout << "\nItem Category: " << setw(10) << ItemID::ItemCategory;
cout << "\nOriginal Price: " << setw(1) << "$" << OriginalPrice;
cout << "\nDiscount: " << setw(8) << "$" << DiscountAmount;
cout << "\nTax Rate: " << setw(12) << TaxRate;
cout << "\nTax Amount " << setw(7) << "$" << TaxAmount;
cout << "\nNet Price: " << setw(6) << "$" << NetPrice;
cout << "\n\nPress any key to continue...";
getch();
return 0;
}
//---------------------------------------------------------------------------
|
The C++ Standard provides a namespace called std. The
std namespace includes a series of libraries that you will routinely and
regularly use in your programs. In the implementation of the Borland C++ Builder
compiler, the std namespace contains almost all possible libraries you
will need when creating your console applications.
The following libraries are part of the std namespace:
algorithm |
iomanip |
list |
ostream |
streambuf |
bitset |
ios |
locale |
queue |
string |
complex |
iosfwd |
map |
set |
typeinfo |
deque |
iostream |
memory |
sstream |
utility |
exception |
istream |
new |
stack |
valarray |
fstream |
iterator |
numeric |
stdexcept |
vector |
functional |
limits |
|
|
|
The following additional libraries can be used to include C header files into
a C++ program:
cassert |
cios646 |
csetjmp |
cstdio |
ctime |
cctype |
climits |
csignal |
cstdlib |
cwchar |
cerrno |
clocale |
cstdarg |
cstring |
cwctype |
cfloat |
cmath |
cstddef |
Therefore, whenever you need to use a library that is part
of the std namespace, instead of typing a library with its file
extension, as in iostream.h, you can just type the name of the library as
in iostream. Then, on the second line, type using namespace std;. As an example, instead of typing
#include <iostream.h>
You can type:
#include <iostream>
using namespace std;
Because this second technique is conform with the C++ Standard, we will use it
whenever we need one of its libraries.
The Borland C++ Builder compiler is equipped with many
namespaces. In fact, unlike most other compilers, (almost) everything in C++
Builder is included in a a certain namespace. most of the time, you will not be
concerned with this fact but some of the classes you will need when doing
graphical programming require explicit call to a namespace.
|