DevX Home Today's Headlines   Articles Archive   Tip Bank   Forums

# Thread: C++ solutions for : [Object-Oriented Programming in C++, Third Edition]

1. CHAPTER 5—FUNCTIONS code;

Code:
```/**1.  Refer to the CIRCAREA program in Chapter 2, “C++ Programming Basics.” Write a function
called circarea() that finds the area of a circle in a similar way. It should take an argument of type float
and return an argument of the same type. Write a main() function that gets a radius value from the
user, calls circarea(), and displays the result.*/
#include<iostream>
#include<conio.h>
using namespace std;

float circarea(float radius);

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// circarea.cpp
// demonstrates floating point variables
#include <iostream>                     //for cout, etc.
using namespace std;

int main()
{
float rad;                           //variable of type float
const float PI = 3.14159F;           //type const float

cout << "Enter radius of circle: ";  //prompt
cin >> rad;                          //get radius
float area = PI * rad * rad;         //find area
cout << "Area is " << area << endl;  //display answer
return 0;
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

float rad;

do{
cout<<"Enter radius of circle: "; cin>> rad;
cout <<"Area is "<<circarea(rad);
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}

float circarea(float radius) { return 3.14159F*radius*radius;}```
Code:
```/**2.  Raising a number n to a power p is the same as multiplying n by itself p times. Write a function
called power() that takes a double value for n and an int value for p, and returns the result as a double
value. Use a default argument of 2 for p, so that if this argument is omitted, the number n will be
squared. Write a main() function that gets values from the user to test this function.*/
#include<iostream>
#include<conio.h>
using namespace std;

double power(double n, int p=2);

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

double n; int p=2;

do{
cout<<"Enter n: "; cin>> n;
cout<<"Enter p: "; cin>> p;
cout <<"The power is "<<power(n, p);
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}

double power(double n, int p){ for(int ret=1; p>0; p--) ret*=n; return ret;}```
Code:
```/**3.  Write a function called zeroSmaller() that is passed two int arguments by reference and then sets
the smaller of the two numbers to 0. Write a main() program to exercise this function.*/
#include<iostream>
#include<conio.h>
using namespace std;

bool zeroSmaller(int& n1, int& n2);

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

int n1, n2;

do{
cout<<"Enter n1: "; cin>> n1;
cout<<"Enter n2: "; cin>> n2;
cout <<"The number assigned to zero is ";
if(zeroSmaller(n1, n2)) cout<<"n1"; else cout<<"n2";
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}

bool zeroSmaller(int& n1, int& n2){
if(n1<n2) {n1=0; return true;}
else {n2=0;return false;}}```
Code:
```/**4.  Write a function that takes two Distance values as arguments and returns the larger one. Include
a main() program that accepts two Distance values from the user, compares them, and displays the
larger. (See the retstrc program for hints.).*/
#include<iostream>
#include<conio.h>
using namespace std;

int distWatch(int d1, int d2);

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

int d1, d2;

do{
cout<<"Enter d1: "; cin>> d1;
cout<<"Enter d2: "; cin>> d2;
cout <<"The largest distance is "<<distWatch(d1, d2);
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}

int distWatch(int d1, int d2){ if(d1<d2) return d2; else return d1;}```
Code:
```/*5.  Write a function called hms_to_secs() that takes three int values—for hours, minutes, and
seconds—as arguments, and returns the equivalent time in seconds (type long). Create a program
that exercises this function by repeatedly obtaining a time value in hours, minutes, and seconds from
the user (format 12:59:59), calling the function, and displaying the value of seconds it returns.*/
#include<iostream>
#include<conio.h>
using namespace std;

long hms_to_secs(int hours, int minutes, int seconds);

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

int h, m, s; char sep;

do{
cout<<"Enter the time in format hh:mm:ss : "; cin>>h>>sep>>m>>sep>>s;
cout <<"The equivalent time in seconds is : "<<hms_to_secs(h, m, s);
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}

long hms_to_secs(int hours, int minutes, int seconds){ return
seconds+minutes*60+hours*3600;}```

2. Code:
```/*6.  Start with the program from Exercise 11, Chapter 4, “Structures,” which adds two struct time
values. Keep the same functionality, but modify the program so that it uses two functions. The first,
time_to_secs(), takes as its only argument a structure of type time, and returns the equivalent in
seconds (type long). The second function, secs_to_time(), takes as its only argument a time in
seconds (type long), and returns a structure of type time. */
#include<iostream>
#include<conio.h>
using namespace std;

struct time{int hours; int minutes; int seconds;};
long time_to_secs(time t);
time secs_to_time(long s);

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

time t1, t2, t3; char c;

do{
cout<<"In [hh:mm:ss] format;\n";
cout<<"Enter first time value : "; cin >>t1.hours>>c>>t1.minutes>>c>>t1.seconds;
cout<<"Enter second time value: "; cin >>t2.hours>>c>>t2.minutes>>c>>t2.seconds;
t3=secs_to_time(time_to_secs(t1)+time_to_secs(t2));
cout<<"The result is: "<<t3.hours<<":"<<t3.minutes<<":"<<t3.seconds;
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}

long time_to_secs(time t){ return t.hours*3600+t.minutes*60+t.seconds;}
time secs_to_time(long s){
time t;
t.seconds=s%60; t.minutes=((s-t.seconds)%3600)/60; t.hours=s/3600;
if(t.seconds>59) {t.seconds-=59; t.minutes++;} //Check seconds over.
if(t.minutes>59) {t.minutes-=59; t.hours++;}   //Check minutes over.
return t;
}```
Code:
```/*7.  Start with the power () function of Exercise 2, which works only with type double. Create a series
of overloaded functions with the same name that, in addition to double, also work with types char,
int, long, and float. Write a main() program that exercises these overloaded functions with all
argument types.*/
#include<iostream>
#include<conio.h>
using namespace std;

double power(double n, int p=2);
char   power(char   n, int p=2);
int    power(int    n, int p=2);
long   power(long   n, int p=2);
float  power(float  n, int p=2);

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

char sep; int p=2; double d_n; char c_n; int i_n; long l_n; float f_n;

do{
cout<<"In [n^p] format;\n";
cout<<"Enter a double type n : "; cin >>d_n>>sep>>p;
cout<<"The power is "<<power(d_n, p)<<endl;
cout<<"Enter a char type n   : "; cin >>c_n>>sep>>p;
cout<<"The power is "<<power(c_n, p)<<endl;
cout<<"Enter a int type n    : "; cin >>i_n>>sep>>p;
cout<<"The power is "<<power(i_n, p)<<endl;
cout<<"Enter a long type n   : "; cin >>l_n>>sep>>p;
cout<<"The power is "<<power(l_n, p)<<endl;
cout<<"Enter a float type n  : "; cin >>f_n>>sep>>p;
cout<<"The power is "<<power(f_n, p)<<endl;
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}

double power(double n, int p){ for(int ret=1; p>0; p--) ret*=n; return ret;}
char   power(char   n, int p){ for(int ret=1; p>0; p--) ret*=n; return ret;}
int    power(int    n, int p){ for(int ret=1; p>0; p--) ret*=n; return ret;}
long   power(long   n, int p){ for(int ret=1; p>0; p--) ret*=n; return ret;}
float  power(float  n, int p){ for(int ret=1; p>0; p--) ret*=n; return ret;}```
Code:
```/*8.  Write a function called swap() that interchanges two int values passed to it by the calling program.
(Note that this function swaps the values of the variables in the calling program, not those in the
function.) You’ll need to decide how to pass the arguments. Create a main() program to exercise the
function.*/
#include<iostream>
#include<conio.h>
using namespace std;

void swap(int& a, int& b);

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

int a, b;

do{
cout<<"Enter a : "; cin >>a;
cout<<"Enter b : "; cin >>b; swap(a, b);
cout<<"Now a value is : "<<a<<" and b value is : "<<b;
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}

void swap(int& a, int& b){int c=a; a=b; b=c;}```
Code:
```/*9.  This exercise is similar to Exercise 8, except that instead of two int variables, have the swap()
function interchange two struct time values (see Exercise 6).*/
#include<iostream>
#include<conio.h>
using namespace std;

struct time{int hours; int minutes; int seconds;};
void swap(time& t1, time& t2);

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

time t1, t2; char c;

do{
cout<<"In [hh:mm:ss] format;\n";
cout<<"Enter first time value : "; cin >>t1.hours>>c>>t1.minutes>>c>>t1.seconds;
cout<<"Enter second time value: "; cin >>t2.hours>>c>>t2.minutes>>c>>t2.seconds;
swap(t1, t2);
cout<<"Now first time is : "  <<t1.hours<<c<<t1.minutes<<c<<t1.seconds
<<" and second time is : "<<t2.hours<<c<<t2.minutes<<c<<t2.seconds;
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}

void swap(time& a, time& b){time c=a; a=b; b=c;}```
Code:
```/*10.  Write a function that, when you call it, displays a message telling how many times it has been
called: “I have been called 3 times”, or whatever. Write a main() program that calls this function at
least 10 times. Try implementing this function in two different ways. First, use an external variable to
store the count. Second, use a local static variable. Which is more appropriate? Why can’t you use
an automatic variable?*/
#include<iostream>
#include<conio.h>
using namespace std;

void caller_counter(void);

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

int outer_counter=0;

do{
outer_counter++; caller_counter();
cout<<"\nThe main programme counter value is: "<<outer_counter;
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}

void caller_counter(void){
//I can't use an automatic variable coz it's created once I call the function only.
static int inner_counter=0; inner_counter++;
cout<<"I have been called "<<inner_counter<<" times";}```

3. Code:
```/*11.  Write a program, based on the sterling structure of Exercise 10 in Chapter 4, “Structures,” that
obtains from the user two money amounts in old-style British format (£9:19:11), adds them, and
displays the result, again in old-style format. Use three functions. The first should obtain a pounds-
shillings-pence value from the user and return the value as a structure of type sterling. The second
should take two arguments of type sterling and return a value of the same type, which is the sum of
the arguments. The third should take a sterling structure as its argument and display its value.*/
#include<iostream>
#include<conio.h>
using namespace std;

struct sterling{int pounds; int shillings; int pence;};
sterling psp_to_sterling(int pounds, int shillings, int pence);
sterling sterling_add(sterling s1, sterling s2);
void sterling_disp(sterling s);
char c;

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

int x, y, z; sterling x1, x2;

do{
cout<<"In [9:19:11] format;\n";
cout<<"Enter first money amount in old-style British  : \x9c";
cin>>x>>c>>y>>c>>z; x1=psp_to_sterling(x, y, z);
cout<<"Enter second money amount in old-style British : \x9c";
cin>>x>>c>>y>>c>>z; x2=psp_to_sterling(x, y, z);
sterling_disp(sterling_add(x1, x2));
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}

sterling psp_to_sterling(int pounds, int shillings, int pence){
sterling x;	x.pounds=pounds; x.shillings=shillings; x.pence=pence; return x;}

sterling sterling_add(sterling s1, sterling s2){
s1.pounds += s2.pounds; s1.shillings += s2.shillings; s1.pence += s2.pence;
if(s1.pence>11){s1.shillings += static_cast<int>(s1.pence/12); s1.pence %= 12;}
if(s1.shillings>19){s1.pounds += static_cast<int>(s1.shillings/20); s1.shillings %= 20;}
return s1;}

void sterling_disp(sterling s){
cout<<"Total is                                       : \x9c"
<<s.pounds<<c<<s.shillings<<c<<s.pence;}```
Code:
```/*12.  Revise the four-function fraction calculator from Exercise 12, Chapter 4, so that it uses
functions for each of the four arithmetic operations. They can be called fadd(), fsub(), fmul(), and fdiv
(). Each of these functions should take two arguments of type struct fraction, and return an argument
of the same type.*/
#include<iostream>
#include<conio.h>
using namespace std;

struct fraction{int numerator; int denominator;};
fraction fadd(fraction a, fraction b);
fraction fsub(fraction a, fraction b);
fraction fmul(fraction a, fraction b);
fraction fdiv(fraction a, fraction b);

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

fraction f[3]; char c, op;

do{
cout<<"Enter your task : ";
cin >>f[0].numerator>>c>>f[0].denominator>>op>>f[1].numerator>>c>>f[1].denominator;
if(!f[0].denominator || !f[1].denominator) {cout<<"Illeagle fraction !"<<endl; op=false;}
switch(op) {
case '+':	f[2]=fadd(f[0], f[1]); break;
case '-':	f[2]=fsub(f[0], f[1]); break;
case '*':	f[2]=fmul(f[0], f[1]); break;
case '/':	f[2]=fdiv(f[0], f[1]); break;
default:	cout<<"Unknow operator please try again !"<<endl;}
cout<<"Answer = "<<f[2].numerator<<c<<f[2].denominator;
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}

fraction fadd(fraction a, fraction b){
fraction f;
f.numerator  =a.numerator*b.denominator+a.denominator*b.numerator;
f.denominator=a.denominator*b.denominator; return f;}

fraction fsub(fraction a, fraction b){
fraction f;
f.numerator  =a.numerator*b.denominator-a.denominator*b.numerator;
f.denominator=a.denominator*b.denominator; return f;}

fraction fmul(fraction a, fraction b){
fraction f;
f.numerator  =a.numerator*b.numerator;
f.denominator=a.denominator*b.denominator; return f;}

fraction fdiv(fraction a, fraction b){
fraction f;
if(b.numerator != 0){
f.numerator  =a.numerator*b.denominator;
f.denominator=b.numerator*a.denominator;}
else              cout<<"Math error !"<<endl; return f;}```

4. CHAPTER 6—OBJECTS AND CLASSES

Questions:
----------
1. What is the purpose of a class declaration?
2. A ________ has the same relation to an ________ that a basic data type has to a variable of that type.
3. In a class declaration, data or functions designated private are accessible
a. to any function in the program.
b. only if you know the password.
c. to member functions of that class.
d. only to public members of the class.
4. Write a class declaration that creates a class called leverage with one private data member, crowbar, of type int and one public function whose declaration is void pry().
5. True or false: Data items in a class must be private.
6. Write a statement that defines an object called lever1 of the leverage class described in Question 4.
7. The dot operator (or class member access operator) connects the following two entities (reading from left to right):
a. A class member and a class object
b. A class object and a class
c. A class and a member of that class
d. A class object and a member of that class
8. Write a statement that executes the pry() function in the lever1 object, as described in Questions 4 and 6.
9. Member functions defined inside a class declaration are ________ by default.
10. Write a member function called getcrow() for the leverage class described in Question 4. This function should return the value of the crowbar data. Assume the function is defined within the class declaration.
11. A constructor is executed automatically when an object is ________.
12. A constructor’s name is the same as _________.
13. Write a constructor that initializes to 0 the crowbar data, a member of the leverage class described in Question 4. Assume the constructor is defined within the class declaration.
14. True or false: In a class you can have more than one constructor with the same name.
15. A member function can always access the data
a. in the object of which it is a member.
b. in the class of which it is a member.
c. in any object of the class of which it is a member.
d. in the public part of its class.
16. Assume the member function getcrow() described in Question 10 is defined outside the class declaration. Write the declaration that goes inside the class declaration.
17. Write a revised version of the getcrow() member function from Question 10 that is defined outside the class declaration.
18. The only technical difference between structures and classes in C++ is that _________.
19. If three objects of a class are defined, how many copies of that class’s data items are stored in memory? How many copies of its member functions?
20. Sending a message to an object is the same as _________.
21. Classes are useful because they
a. are removed from memory when not in use.
b. permit data to be hidden from other classes.
c. bring together all aspects of an entity in one place.
d. can closely model objects in the real world.
22. True or false: There is a simple but precise methodology for dividing a real–world programming problem into classes.
23. For the object for which it was called, a const member function
a. can modify both const and non–const member data.
b. can modify only const member data.
c. can modify only non–const member data.
d. can modify neither const nor non–const member data.
24. True or false: If you declare a const object, it can only be used with const member functions.
25. Write a declaration (not a definition) for a const void function called aFunc() that takes one const argument called jerry of type float.
__________
My answers:
-----------
1. Manage objects formation.
2. Class, Object.
3. to member functions of that class.
4. class leverage{int crowbar; public: void pry();};
5. False.
6. leverage lever1;
7. A class object and a member of that class.
8. lever1.pry();
9. private.
10. int getcrow(){ return crowbar;}
11. defined.
12. class.
13. levrage(): crowbar(0){}
14. True.
15. in the object of which it is a member.
16. int getcrow();
17. int leverage::getcrow(){ return crowbar;}
18. members are by default public in struct, and private in class.
19. 3, 1.
20. passing to a function.
21. permit data to be hidden from other classes, bring together all aspects of an entity in one place, can closely model objects in the real world.
22. True.
23. can modify neither const nor non–const member data.
24. False.
25. void aFunc(const float jerry) const;
___________
Answers:
--------
1. A class declaration describes how objects of a class will look when they are created.
2. class, object
3. c
4.
class leverage
{
private:
int crowbar;
public:
void pry();
};

5. False; both data and functions can be private or public.
6. leverage lever1;
7. d
8. lever1.pry();
9. inline (also private)
10.
int getcrow()
{ return crowbar; }

11. created (defined)
12. the class of which it is a member
13.
leverage()
{ crowbar = 0; }

14. True
15. a
16. int getcrow();
17.
int leverage::getcrow()
{ return crowbar; }

18. member functions and data are, by default, public in structures but private in classes
19. three, one
20. calling one of its member functions
21. b, c, d
22. False; trial and error may be necessary.
23. d
24. True
25. void aFunc(const float jerry) const;
________

5. CHAPTER 6—OBJECTS AND CLASSES codes;

Code:
```/**1.  Create a class that imitates part of the functionality of the basic data type int.Call the class Int
(note different spelling). The only data in this class is an int variable. Include member functions to
initialize an Int to 0, to initialize it to an int value, to display it (it looks just like an int), and to add two
Int values.
Write a program that exercises this class by creating two initialized and one uninitialized Int values,
adding these two initialized values and placing the response in the uninitialized value, and then
displaying this result.*/
#include<iostream>
#include<conio.h>
using namespace std;

class Int{
int int_var;
public:
Int(): int_var(0){}
Int(int begin): int_var(begin){}
void display() const{ cout<<int_var;}
void add(Int x, Int y){ int_var=x.int_var+y.int_var;}
};

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

Int a=5, b=7, c;

do{
c.add(a,b);
c.display();
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}```
Code:
```/**2.  Imagine a tollbooth at a bridge. Cars passing by the booth are expected to pay a 50 cent toll.
Mostly they do, but sometimes a car goes by without paying. The tollbooth keeps track of the
number of cars that have gone by, and of the total amount of money collected.
Model this tollbooth with a class called tollBooth. The two data items are a type unsigned int to hold
the total number of cars, and a type double to hold the total amount of money collected. A
constructor initializes both of these to 0. A member function called payingCar() increments the car
total and adds 0.50 to the cash total. Another function, called nopayCar(), increments the car total
but adds nothing to the cash total. Finally, a member function called display() displays the two totals.
Make appropriate member functions const.
Include a program to test this class. This program should allow the user to push one key to count a
paying car, and another to count a nonpaying car. Pushing the [Escape] key should cause the
program to print out the total cars and total cash and then exit. */
#include<iostream>
#include<conio.h>
using namespace std;

class tollBooth{
unsigned int num_cars;
double money_amount;
public:
tollBooth(): num_cars(0), money_amount(0) {}
void payingCar(){ num_cars++; money_amount+=.5;}
void nopayCar(){ num_cars++;}
void display() const {
cout<<"\rTotal number of cars is: "<<num_cars;
cout<<"\nTotal money amount is  : "<<money_amount;}
};

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

tollBooth x;

do{
for(;;){
switch(toupper(getch())){
case('P'): x.payingCar(); cout<<"\rPayed";   break;
case('N'): x.nopayCar(); cout<<"\rNot payed"; break;
case(27 ): x.display(); goto end;}
}
end:
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}```
Code:
```/**3.  Create a class called time that has separate int member data for hours, minutes, and seconds.
One constructor should initialize this data to 0, and another should initialize it to fixed values.
Another member function should display it, in 11:59:59 format. The final member function should
add two objects of type time passed as arguments.
A main() program should create two initialized time objects (should they be const?) and one that isn’t
initialized. Then it should add the two initialized values together, leaving the result in the third time
variable. Finally it should display the value of this third variable. Make appropriate member
functions const.  */
#include<iostream>
#include<conio.h>
using namespace std;

class time{
int hours, minutes, seconds;
public:
time(): hours(0), minutes(0), seconds(0) {}
time(int h, int m, int s): hours(h), minutes(m), seconds(s) {}
void display() const { cout<<hours<<":"<<minutes<<":"<<seconds;}
void add(time x, time y){
long tmp;
tmp=x.hours*3600+x.minutes*60+x.seconds+y.hours*3600+y.minutes*60+y.seconds;
seconds=tmp%60; minutes=((tmp-seconds)%3600)/60; hours=tmp/3600;
if(seconds>59) {seconds-=59; minutes++;}
if(minutes>59) {minutes-=59; hours++;}}};

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

const time t1(12, 34, 4), t2(3, 34, 45);
time t3;

do{
t3.add(t1, t2);
t3.display();
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}```
Code:
```/*4.  Create an employee class, basing it on Exercise 4 of Chapter 4. The member data should
comprise an int for storing the employee number, and a float for storing the employee’s
compensation. Member functions should allow the user to enter this data and display it. Write a main
() that allows the user to enter data for three employees and display it.*/
#include<iostream>
#include<iomanip>
#include<conio.h>
using namespace std;

class employee{
int emp_num;
float emp_comp;
public:
void assign(int en, float ec){ emp_num=en; emp_comp=ec;}
void disp() const { cout<<endl<<setw(25)<<emp_num<<setw(25)<<emp_comp;}
};

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

employee x[3]; int a; float b;

do{
for(int i=0; i<3;){
cout<<"Enter the employee "<<++i<<" number      : "; cin>>a;
cout<<"Enter the employee "<<  i<<" compensation: "; cin>>b;
x[i-1].assign(a, b);}
cout<<setw(25)<<"employees number"<<setw(25)<<"employee's compensation";
for(int j=0; j<3; j++) { x[j].disp();}
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}```
Code:
```/*5.  Start with the date structure in Exercise 5 in Chapter 4 and transform it into a date class. Its
member data should consist of three ints: month, day, and year. It should also have two member
functions: getdate(), which allows the user to enter a date in 12/31/97 format, and showdate(), which
displays the date. */
#include<iostream>
#include<conio.h>
using namespace std;

class date{
int day, month, year;
char c;
public:
void getdate(){
cout<<"Enter date in [12/31/97] format: ";
cin >>day>>c>>month>>c>>year;}
void showdate() const { cout<<"Date is: "<<day<<c<<month<<c<<year;}};

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

date x;

do{
x.getdate(); x.showdate();
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}```

6. Code:
```/*6.  Extend the employee class of Exercise 4 to include a date class (see Exercise 5) and an etype enum
(see Exercise 6 in Chapter 4). An object of the date class should be used to hold the date of first
employment; that is, the date when the employee was hired. The etype variable should hold the
employee’s type: laborer, secretary, manager, and so on. These two items will be private member
data in the employee declaration, just like the employee number and salary. You’ll need to extend the
getemploy() and putemploy() functions to obtain this new information from the user and display it.
These functions will probably need switch statements to handle the etype variable. Write a main()
program that allows the user to enter data for three employee variables, which then displays this data. */
#include<iostream>
#include<iomanip>
#include<conio.h>
using namespace std;

class employee{
class date{
int day, month, year;
char c;
public:
void getdate(){
cout<<"Enter date in [12/31/97] format: ";
cin >>day>>c>>month>>c>>year;}
void showdate() const { cout<<setw(10)<<day<<c<<month<<c<<year;}};
int emp_num; float emp_comp;
date y; char *ret;
enum etype { laborer, secretary, manager, accountant, executive, researcher };
public:
void putemploy(int en, float ec);
void getemploy() const {
cout<<setw(15)<<emp_num<<setw(25)<<emp_comp<<setw(15)<<ret;
y.showdate(); cout<<endl; }};

void employee::putemploy(int en, float ec){
emp_num=en; emp_comp=ec;
etype x; y.getdate();
cout<<"Enter employee type (first letter only)"<<endl
<<"(laborer, secretary, manager, accountant, executive, researcher): ";
switch(getche()){
case 'l': x=laborer   ; break;
case 's': x=secretary ; break;
case 'm': x=manager   ; break;
case 'a': x=accountant; break;
case 'e': x=executive ; break;
case 'r': x=researcher;}
switch(x){
case 0: ret = "laborer"   ; break;
case 1: ret = "secretary" ; break;
case 2: ret = "manager"   ; break;
case 3: ret = "accountant"; break;
case 4: ret = "executive" ; break;
case 5: ret = "researcher"; break;
default: ret = "Undefined";}}

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

employee x[3]; int a; float b;

do{
for(int i=0; i<3;){
cout<<"\nEnter the employee "<<++i<<" number      : "; cin>>a;
cout<<"Enter the employee "<<  i<<" compensation: "; cin>>b;
x[i-1].putemploy(a, b);}
cout<<endl<<setw(15)<<"employees number"
<<setw(25)<<"employee's compensation"
<<setw(15)<<"Employee type"
<<setw(15)<<"Date\n";
for(int j=0; j<3; j++) { x[j].getemploy();}
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}```
Code:
```/*7.  In ocean navigation, locations are measured in degrees and minutes of latitude and longitude.
Thus if you’re lying off the mouth of Papeete Harbor in Tahiti, your location is 149 degrees 34.8
minutes west longitude, and 17 degrees 31.5 minutes south latitude. This is written as 149°34.8’W,
17°31.5’S. There are 60 minutes in a degree. (An older system also divided a minute into 60
seconds, but the modern approach is to use decimal minutes instead.) Longitude is measured from 0
to 180 degrees, east or west from Greenwich, England, to the international dateline in the Pacific.
Latitude is measured from 0 to 90 degrees, north or south from the equator to the poles.
Create a class angle that includes three member variables: an int for degrees, a float for minutes,
and a char for the direction letter (N, S, E, or W). This class can hold either a latitude variable or a
longitude variable. Write one member function to obtain an angle value (in degrees and minutes) and
a direction from the user, and a second to display the angle value in 179°59.9’E format. Also write
a three–argument constructor. Write a main() program that displays an angle initialized with the
constructor, and then, within a loop, allows the user to input any angle value, and then displays the
value. You can use the hex character constant ‘\xF8’ which usually prints a degree (°) symbol. */
#include<iostream>
#include<conio.h>
using namespace std;

class angle{
int degrees;
float minutes;
char direction;
public:
angle(int deg, float min, char dir){ degrees=deg, minutes=min, direction=dir;}
void getAngle(int deg, float min, char dir){ degrees=deg; minutes=min; direction=dir;}
void disp() const { cout<<degrees<<"\xF8"<<minutes<<"\'"<<direction<<endl;}
};

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

angle A(17, 31.5f, 'S');
int a; float b; char c;
A.disp();

do{
cout<<"Enter degrees  : "; cin>>a;
cout<<"Enter minutes  : "; cin>>b;
cout<<"Enter direction: "; cin>>c;
A.getAngle(a, b, c);
A.disp();
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}```
Code:
```/*8.  Create a class that includes a data member that holds a “serial number” for each object created
from the class. That is, the first object created will be numbered 1, the second 2, and so on.
To do this, you’ll need another data member that records a count of how many objects have been
created so far. (This member should apply to the class as a whole; not to individual objects. What
keyword specifies this?) Then, as each object is created, its constructor can examine this count
member variable to determine the appropriate serial number for the new object.
Add a member function that permits an object to report its own serial number. Then write a main()
program that creates three objects and queries each one about its serial number. They should
respond I am object number 2, and so on.*/
#include<iostream>
#include<conio.h>
using namespace std;

class SN{
static int count;
int serial;
public:
SN() { serial=++count;} //could make another function but no need for it !
void disp() const { cout<<"I\'am object number "<<serial<<endl;}
};  int SN::count=0;

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

do{
SN s[3];
for(int i=0; i<3; i++) s[i].disp();
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}```
Code:
```/*9.  Transform the fraction structure from Exercise 8, Chapter 4 into a fraction class. Member data is
the fraction’s numerator and denominator. Member functions should accept input from the user in
the form 3/5, and output the fraction’s value in the same format. Another member function should
add two fraction values. Write a main() program that allows the user to repeatedly input two
fractions, and which then displays their sum. After each operation ask if the user wants to continue.*/
#include<iostream>
#include<conio.h>
using namespace std;

class fraction{
int numerator, denominator;
char c;
void dispFct() const { cout<<numerator<<"/"<<denominator;}
public:
void getFct(){ cout<<"Enter fraction: "; cin>>numerator>>c>>denominator;}
void addFct(fraction x, fraction y){
numerator=x.numerator*y.denominator+x.denominator*y.numerator;
denominator=x.denominator*y.denominator;
cout<<"Sum = "; dispFct();}};

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

fraction f[3];

do{
f[0].getFct(); f[1].getFct();
f[2].addFct(f[0], f[1]);
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}```
Code:
```/*10.  Create a class called ship that incorporates a ship’s number and location. Use the approach of
Exercise 8 to number each ship object as it is created. Use two variables of the angle class from
Exercise 7 to represent the ship’s latitude and longitude. A member function of the ship class should
get a position from the user and store it in the object; another should report the serial number and
position. Write a main() program that creates three ships, asks the user to input the position of each,
and then displays each ship’s number and position. */
#include<iostream>
#include<conio.h>
using namespace std;

class SN{
static int count;
int serial;
public:
SN() { serial=++count;}
void disp() const { cout<<serial;}
};  int SN::count=0;

class angle{
int degrees;
float minutes;
char direction;
public:
void getAngle(){
cout<<"Enter degrees  : "; cin>>degrees;
cout<<"Enter minutes  : "; cin>>minutes;
cout<<"Enter direction: "; cin>>direction;}
void disp() const { cout<<degrees<<"\xF8"<<minutes<<"\'"<<direction;}};

class ship{
SN s;
angle a1, a2;
public:
void getPos() { a1.getAngle(); a2.getAngle();}
void disp() const {
cout<<"Ship number: "; s.disp();
cout<<" position: "; a1.disp(); cout<<", "; a2.disp(); cout<<endl;}};

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

ship s[3];

do{
for(int i=0; i<3; i++) s[i].getPos();
for(int j=0; j<3; j++) s[j].disp();
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}```

7. Code:
```/*11.  Modify the four–function fraction calculator of Exercise 12, Chapter 5 to use a fraction class
rather than a structure. There should be member functions for input and output, as well as for the
four arithmetical operations. While you’re at it, you might as well install the capability to reduce
fractions to lowest terms. Here’s a member function that will reduce the fraction object of which it is
a member to lowest terms. It finds the greatest common divisor (gcd) of the fraction’s numerator
and denominator, and uses this gcd to divide both numbers.

void fraction::lowterms()     // change ourself to lowest terms
{
long tnum, tden, temp, gcd;

tnum = labs(num);          // use non–negative copies
tden = labs(den);          //    (needs cmath)
if(tden==0 )   // check for n/0
{ cout << “Illegal fraction: division by 0”; exit(1); }
else if( tnum==0 )         // check for 0/n
{ num=0; den = 1; return; }

// this ‘while’ loop finds the gcd of tnum and tden
while(tnum != 0)
{
if(tnum < tden)         // ensure numerator larger
{ temp=tnum; tnum=tden; tden=temp; }  // swap them
tnum = tnum – tden;     // subtract them
}
gcd = tden;                // this is greatest common divisor
num = num / gcd;           // divide both num and den by gcd
den = den / gcd;           // to reduce frac to lowest terms
}

You can call this function at the end of each arithmetic function, or just before you perform output.
You’ll also need the usual member functions: four arithmetic operations, input, and display. You may
find a two–argument constructor useful. */
#include<iostream>
#include<conio.h>
using namespace std;

class fraction{
public:
int numerator, denominator;
void fadd(fraction a, fraction b);
void fsub(fraction a, fraction b);
void fmul(fraction a, fraction b);
void fdiv(fraction a, fraction b);
void lowterms();
void disp() const { cout<<"Answer = "<<numerator<<"/"<<denominator;}};

void fraction::lowterms(){ /*===Edited By Amahdy=====*/
long tnum, tden, temp;
tnum = labs(numerator); //labs() to get the absolute value of a long.
tden = labs(denominator);
if(!(tnum)){ numerator=0; denominator=1; return;}
while(tnum != 0){
if(tnum<tden){ temp=tnum; tnum=tden; tden=temp;}
tnum-=tden;}
numerator/=tden; denominator/=tden;}

void fraction::fadd(fraction a, fraction b){
numerator  =a.numerator*b.denominator+a.denominator*b.numerator;
denominator=a.denominator*b.denominator;}

void fraction::fsub(fraction a, fraction b){
numerator  =a.numerator*b.denominator-a.denominator*b.numerator;
denominator=a.denominator*b.denominator;}

void fraction::fmul(fraction a, fraction b){
numerator  =a.numerator*b.numerator;
denominator=a.denominator*b.denominator;}

void fraction::fdiv(fraction a, fraction b){
if(b.numerator != 0){
numerator  =a.numerator*b.denominator;
denominator=b.numerator*a.denominator;}
else         cout<<"Math error !"<<endl;}

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

fraction f[3]; char c, op;

do{
cout<<"Enter your task : ";
cin >>f[0].numerator>>c>>f[0].denominator>>op>>f[1].numerator>>c>>f[1].denominator;
if(!f[0].denominator || !f[1].denominator) {cout<<"Illeagle fraction !"<<endl; op=false;}
switch(op) {
case '+':	f[2].fadd(f[0], f[1]); break;
case '-':	f[2].fsub(f[0], f[1]); break;
case '*':	f[2].fmul(f[0], f[1]); break;
case '/':	f[2].fdiv(f[0], f[1]); break;
default:	cout<<"Unknow operator please try again !"<<endl;}
f[2].lowterms();
cout<<"Answer = "<<f[2].numerator<<c<<f[2].denominator;
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}```
Code:
```/*12.  Note that one advantage of the OOP approach is that an entire class can be used, without
modification, in a different program. Use the fraction class from Exercise 11 in a program that
generates a multiplication table for fractions. Let the user input a denominator, and then generate all
combinations of two such fractions that are between 0 and 1, and multiply them together. Here’s an
example of the output if the denominator is 6:

1/6     1/3    1/2    2/3    5/6

–––––––––––––––––––––––––––––––––––––––––
1/6    1/36    1/18   1/12   1/9    5/36
1/3    1/18    1/9    1/6    2/9    5/18
1/2    1/12    1/6    1/4    1/3    5/12
2/3    1/9     2/9    1/3    4/9    5/9
5/6    5/36    5/18   5/12   5/9    25/36
*/
#include<iostream>
#include<iomanip>
#include<conio.h>
using namespace std;

class fraction{
int numerator, denominator;
public:
fraction(int num, int den): numerator(num), denominator(den) {}
void fmul(fraction a, fraction b);
void lowterms();
void assign(int num, int den){ numerator=num; denominator=den;}
void dispN() const { cout<<numerator<<"/"<<denominator;}
void disp() const { cout<<setw(7)<<numerator<<"/"<<setw(3)<<denominator;}};

void fraction::lowterms(){ /*===Edited By Amahdy=====*/
long tnum, tden, temp;
tnum = labs(numerator);
tden = labs(denominator);
if(!(tnum)){ numerator=0; denominator=1; return;}
while(tnum != 0){
if(tnum<tden){ temp=tnum; tnum=tden; tden=temp;}
tnum-=tden;}
numerator/=tden; denominator/=tden;}

void fraction::fmul(fraction a, fraction b){
numerator  =a.numerator*b.numerator;
denominator=a.denominator*b.denominator;}

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

fraction f(0, 0), f1(0, 0), f2(0, 0); int x;

do{
cout<<"Enter a number : "; cin>>x; cout<<"   ";
for(int i=0; i<x-1;){ f.assign(++i, x); f.lowterms(); f.disp();}
cout<<endl<<setfill('-')<<setw(10*x)<<' '<<setfill(' ');
for(int j=0; j<x-1;){
cout<<endl; f.assign(++j, x); f.lowterms(); f.dispN();
for(int k=0; k<x-1;){
f1.assign(++k, x); f2.assign(j, x);
f.fmul(f1, f2); f.lowterms(); f.disp();}}
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}```

8. CHAPTER 7—ARRAYS AND STRINGS

Questions:
----------
1. An array element is accessed using
a. a first-in-first-out approach.
b. the dot operator.
c. a member name.
d. an index number.
2. All the elements in an array must be the _________ data type.
3. Write a statement that defines a one-dimensional array called doubleArray of type double that holds 100 elements.
4. The elements of a 10-element array are numbered from ________ to ________.
5. Write a statement that takes element j of array doubleArray and writes it to cout with the insertion operator.
6. Element doubleArray[7] is which element of the array?
a. The sixth
b. The seventh
c. The eighth
d. Impossible to tell
7. Write a statement that defines an array coins of type int and initializes it to the values of the penny, nickel, dime, quarter, half-dollar, and dollar.
8. When a multidimensional array is accessed, each array index is
a. separated by commas.
b. surrounded by brackets and separated by commas.
c. separated by commas and surrounded by brackets.
d. surrounded by brackets.
9. Write an expression that accesses element 4 in subarray 2 in a two-dimensional array called twoD.
10. True or false: In C++ there can be an array of four dimensions.
11. For a two-dimensional array of type float, called flarr, write a statement that declares the array and initializes the first subarray to 52, 27, 83; the second to 94, 73, 49; and the third to 3, 6, 1.
12. An array name, used in the source file, represents the ________ of the array.
13. When an array name is passed to a function, the function
a. accesses exactly the same array as the calling program.
b. accesses a copy of the array passed by the program.
c. refers to the array using the same name as that used by the calling program.
d. refers to the array using a different name than that used by the calling program.
14. Tell what this statement defines: employee emplist[1000];
15. Write an expression that accesses a structure member called salary in a structure variable that is the 17th element in an array called emplist.
16. In a stack, the data item placed on the stack first is
a. not given an index number.
b. given the index number 0.
c. the first data item to be removed.
d. the last data item to be removed.
17. Write a statement that defines an array called manybirds that holds 50 objects of type bird.
18. True or false: The compiler will complain if you try to access array element 14 in a 10-element array.
19. Write a statement that executes the member function cheep() in an object of class bird that is the 27th element in the array manybirds.
20. A string in C++ is an _________ of type _________.
21. Write a statement that defines a string variable called city that can hold a string of up to 20 characters (this is slightly tricky).
22. Write a statement that defines a string constant, called dextrose, that has the value “C6H12O6-H2O”.
23. True or false: The extraction operator (>>) stops reading a string when it encounters a space.
24. You can read input that consists of multiple lines of text using
a. the normal cout << combination.
b. the cin.get() function with one argument.
c. the cin.get() function with two arguments.
d. the cin.get() function with three arguments.
25. Write a statement that uses a string library function to copy the string name to the string blank.
26. Write the declaration for a class called dog that contains two data members: a string called breed and an int called age. (Don’t include any member functions.)
27. True or false: You should prefer C-strings to the Standard C++ string class in new programs.
28. Objects of the string class
a. are zero-terminated.
b. can be copied with the assignment operator.
c. do not require memory management.
d. have no member functions.
29. Write a statement that finds where the string “cat” occurs in the string s1.
30. Write a statement that inserts the string “cat” into string s1 at position 12.
__________
My answers:
-----------
1. an index number.
2. same.
3. double doubleArray[100];
4. 0, 9.
5. cout<<doubleArray[j-1];
6. The eighth.
7. int coins[6] = {penny, nickel, dime, quarter, half-dollar, dollar};
8. surrounded by brackets.
9. twoD[1][3];
10. True;
11. float flarr[3][3] = {52,27,83, 94,73,49, 3,6,1};
12. name.
13. accesses exactly the same array as the calling program.
14. An array called emplist of type employee with size 1000.
15. emplist[16].salary;
16. the last data item to be removed.
17. bird manybirds[50];
18. False.
19. manybirds[26].cheep();
20. array, char.
21. char city[21];
22. const char[] = “C6H12O6-H2O”;
23. True.
24. the cin.get() function with three arguments.
25. strcpy(name, blank);
26. class dog{ string breed; int age;};
27. False.
28. can be copied with the assignment operator, do not require memory management.
29. s1.find("cat");
30. s1.insert(12, "cat");
___________
Answers:
--------
1. d
2. same
3. double doubleArray[100];
4. 0, 9
5. cout << doubleArray[j];
6. c
7. int coins[] = { 1, 5, 10, 25, 50, 100 };
8. d
9. twoD[2][4]
10. True
11. float flarr[3][3] = { {52,27,83}, {94,73,49}, {3,6,1} };
12. memory address
13. a, d
14. an array with 1000 elements of structure or class employee
15. emplist[16].salary
16. d
17. bird manybirds[50];
18. False
19. manybirds[26].cheep();
20. array, char
21. char city[21] (An extra byte is needed for the null character.)
22. char dextrose[] = “C6H12O6-H2O”;
23. True
24. d
25. strcpy(blank, name);
26.
class dog
{
private:
char breed[80];
int age;
};

27. False
28. b, c
29. int n = s1.find(“cat”);
30. s1.insert(12, “cat”);
________

9. CHAPTER 7—ARRAYS AND STRINGS code;

Code:
```/**1.  Write a function called reversit() that reverses a C-string (an array of char). Use a for loop that
swaps the first and last characters, then the second and next-to-last characters, and so on. The
string should be passed to reversit() as an argument.
Write a program to exercise reversit(). The program should get a string from the user, call reversit(),
and print out the result. Use an input method that allows embedded blanks. Test the program with
Napoleon’s famous phrase, “Able was I ere I saw Elba.”*/
#include<iostream>
#include<string>
#include<conio.h>
using namespace std;

void reversit(char str[]){
char tmp; int k=strlen(str);
for(int i=0; i<(k/2); i++){
tmp=str[i]; str[i]=str[k-i-1]; str[k-i-1]=tmp;}}

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

char mystr[80];

do{
cout<<"Enter a string: "; cin>>mystr;
reversit(mystr); cout<<mystr;
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}```
Code:
```/**2.  Create a class called employee that contains a name (an object of class string) and an employee
number (type long). Include a member function called getdata() to get data from the user for insertion
into the object, and another function called putdata() to display the data. Assume the name has no
embedded blanks.
Write a main() program to exercise this class. It should create an array of type employee, and then
invite the user to input data for up to 100 employees. Finally, it should print out the data for all the
employees.*/
#include<iostream>
#include<string>
#include<iomanip>
#include<conio.h>
using namespace std;

class employee{
string name;
long emp_num;
public:
void putdata(){
cout<<"\nEnter the employee name: "; cin>>name;
cout<<"Enter the employee number: "; cin>>emp_num;}
void getdata(){ cout<<endl<<setw(10)<<name<<setw(25)<<emp_num;}};

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

employee emp[100]; int i=0;

do{
while(true){
emp[i++].putdata();
if(i<100){
cout<<"Enter more ? (y) to continue : ";
if(toupper(getche())=='Y') continue;}
break;}
cout<<"\nEmployee name"<<setw(25)<<"Employee number";
for(int j=0; j<i; j++) emp[j].getdata();
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}```
Code:
```/**3.  Write a program that calculates the average of up to 100 English distances input by the user.
Create an array of objects of the Distance class, as in the ENGLARAY example in this chapter. To
calculate the average, you can borrow the add_dist() member function from the ENGLCON example in
Chapter 6. You’ll also need a member function that divides a Distance value by an integer. Here’s
one possibility:

void Distance::div_dist(Distance d2, int divisor)
{
float fltfeet = d2.feet + d2.inches/12.0;
fltfeet /= divisor;
feet = int(fltfeet);
inches = (fltfeet-feet) * 12.0;
}
*/
#include<iostream>
#include<string>
#include<iomanip>
#include<conio.h>
using namespace std;

class Distance{
int feet; float inches;
public:
Distance(): feet(0), inches(0) {}
void getdist(){
cout<<"\nEnter feet: "; cin>>feet;
cout<<"Enter inches: "; cin>>inches;}
void add_dist(Distance d2, Distance d3);
void div_dist(Distance d2, int divisor);
void showdist() const { cout<<feet<<"\'-"<<inches<<'\"';}};

void Distance::add_dist(Distance d2, Distance d3)
{
inches=d2.inches+d3.inches; feet=0;
if(inches>=12.0){ inches -= 12.0; feet++;}
feet += d2.feet+d3.feet;
}

void Distance::div_dist(Distance d2, int divisor)
{
float fltfeet=d2.feet+d2.inches/12.0;
fltfeet /= divisor; feet=int(fltfeet);
inches=(fltfeet-feet)*12.0;
}

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

Distance dist[100], tmp; int i=0;

do{
while(true){
dist[i].getdist(); tmp.add_dist(tmp, dist[i++]);
if(i<100){
cout<<"Enter more ? (y) to continue : ";
if(toupper(getche())=='Y') continue;}
break;}
tmp.div_dist(tmp, i); cout<<"\nAverage is: "; tmp.showdist();
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}```
Code:
```/*4.  Start with a program that allows the user to input a number of integers, and then stores them in
an int array. Write a function called maxint() that goes through the array, element by element, looking
for the largest one. The function should take as arguments the address of the array and the number
of elements in it, and return the index number of the largest element. The program should call this
function and then display the largest element and its index number. (See the SALES program in this
chapter.) */
#include<iostream>
#include<conio.h>
using namespace std;

int maxint(int arr[], int bound){
int max=0;
for(int j=1; j<bound; j++) max= arr[max]>arr[j]? max:j;
return max;}

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

do{
int a[100], i=1;
cout<<"Enter numbers : ([0] to quit) "; cin>>a[0];
while(a[i-1] || i==100) cin>>a[i++];
cout<<"The maximum is: "<<a[maxint(a, i)];
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}```

10. Code:
```/*5.  Start with the fraction class from Exercises 11 and 12 in Chapter 6. Write a main() program that
obtains an arbitrary number of fractions from the user, stores them in an array of type fraction,
averages them, and displays the result*/
#include<iostream>
#include<conio.h>
using namespace std;

class fraction{
char c;
int numerator, denominator;
public:
void fadd(fraction a, fraction b);
void fdiv(fraction a, fraction b);
void getfrac(){ cout<<"Enter fraction: "; cin>>numerator>>c>>denominator;}
void disp() const { cout<<"Maximum = "<<numerator<<"/"<<denominator;}
float getFl(){ if(denominator) return numerator/denominator; else return 0;}};

void fraction::fadd(fraction a, fraction b){
numerator  =a.numerator*b.denominator+a.denominator*b.numerator;
denominator=a.denominator*b.denominator;}

void fraction::fdiv(fraction a, fraction b){
if(b.numerator != 0){
numerator  =a.numerator*b.denominator;
denominator=b.numerator*a.denominator;}
else         cout<<"Math error !"<<endl;}

int maxfrc(fraction arr[], int bound){
int max=0;
for(int j=1; j<bound; j++) max= arr[max].getFl()>arr[j].getFl()? max:j;
return max;}

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

do{
fraction a[100]; int i=1;
cout<<"([0] to quit):\n"; a[0].getfrac();
while(a[i-1].getFl() || i==100) a[i++].getfrac();
a[maxfrc(a, i)].disp();
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}```
Code:
```/*6.  In the game of contract bridge, each of four players is dealt 13 cards, thus exhausting the entire
deck. Modify the CARDARAY program in this chapter so that, after shuffling the deck, it deals four
hands of 13 cards each. Each of the four players’ hands should then be displayed. */
#include<iostream>
#include<conio.h>
using namespace std;
#include<cstdlib>
#include<ctime>

enum Suit{ clubs, diamonds, hearts, spades};
const int jack  = 11;
const int queen = 12;
const int king  = 13;
const int ace   = 14;

class card{
int number;
Suit suit;
public:
void set(int n, Suit s){ suit=s; number=n;}
void display();};

void card::display()
{
if(number>=2 && number<=10) cout<<number;
else switch(number) {
case jack:     cout<<"J";     break;
case queen:    cout<<"Q";     break;
case king:     cout<<"K";     break;
case ace:      cout<<"A";}
switch(suit) {
case clubs:    cout<<char(5); break;
case diamonds: cout<<char(4); break;
case hearts:   cout<<char(3); break;
case spades:   cout<<char(6);}
cout<<"  ";
}

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

card deck[52]; int j, i;

do{
i=0;
for(j=0; j<52; j++){
int num=(j%13)+2; Suit su=Suit(j/13);
deck[j].set(num, su);}
srand(time(NULL));
for(j=0; j<52; j++){
int k=rand()%52; card temp=deck[j];
deck[j]=deck[k]; deck[k]=temp;}
cout<<"\nHand "<<++i<<": ";
for(j=0; j<52; j++){ deck[j].display(); if(!((j+1)%13)&&i<4) cout<<"\nHand "<<++i<<": ";;}
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}```
Code:
```/*7.  One of the weaknesses of C++ for writing business programs is that it does not contain a built-in
type for monetary values such as \$173,698,001.32. Such a money type should be able to store a
number with a fixed decimal point and about 17 digits of precision, which is enough to handle the
national debt in dollars and cents. Fortunately, the built-in C++ type long double has 19 digits of
precision, so we can use it as the basis of a money class, even though it uses a floating decimal.
However, we’ll need to add the capability to input and output money amounts preceded by a dollar
sign and divided by commas into groups of three digits; this makes it much easier to read large
numbers. As a first step toward developing such a class, write a function called mstold() that takes a
money string, a string representing a money amount like

“\$1,234,567,890,123.99”

as an argument, and returns the equivalent long double.
You’ll need to treat the money string as an array of characters, and go through it character by
character, copying only digits (1 to 9) and the decimal point into another string. Ignore everything
else, including the dollar sign and the commas. You can then use the _atold() library function (note
the initial underscore; header file STDLIB.H or MATH.H) to convert the resulting pure string to a long
double. Assume that money values will never be negative. Write a main() program to test mstold() by
repeatedly obtaining a money string from the user and displaying the corresponding long double.  */
#include<iostream>
#include<conio.h>
#include<stdlib.h>
#include<string>
using namespace std;

long mstold(char strm[])
{
string s=" 0123456789"; char ret[20];
//long double x;
for(int i=0, j=0; i<strlen(strm); i++)
if(s.find(strm[i])<20) ret[j++]=strm[i];
return atol(ret);
}

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

char mon[20];

do{
cout<<"Enter a monetary value: "; cin>>mon; cout<<mstold(mon);
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}```
Code:
```/*8.  Another weakness of C++ is that it does not automatically check array indexes to see if they are
in bounds. (This makes array operations faster but less safe.) We can use a class to create a safe
array that checks the index of all array accesses.
Write a class called safearay that uses an int array of fixed size (call it LIMIT) as its only data
member. There will be two member functions. The first, putel(), takes an index number and an int
value as arguments and inserts the int value into the array at the index. The second, getel(), takes an
index number as an argument and returns the int value of the element with that index.

safearay sa1;           // define a safearay object
int temp = 12345;       // define an int value
sa1.putel(7, temp);     // insert value of temp into array at index 7
temp = sa1.getel(7);    // obtain value from array at index 7

Both functions should check the index argument to make sure it is not less than 0 or greater than
LIMIT-1. You can use this array without fear of writing over other parts of memory.
Using functions to access array elements doesn’t look as eloquent as using the [] operator. In
Chapter 8 we’ll see how to overload this operator to make our safearay class work more like built-
in arrays. */
#include<iostream>
#include<conio.h>
using namespace std;

const int LIMIT=100;

class safearay{
int arr[LIMIT];
public:
void putel(int index, int value){ if(index>-1 && index<LIMIT) arr[index]=value;}
int getel(int index){ if(index>-1 && index<LIMIT) return arr[index];}};

void main(void)
{
cout<<"### Programmed By Amahdy(MrJava) ,right restricted.~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
cout<<"-------------------------------------------------------------------------------\n"<<endl;

safearay sa1; int temp=12345;

do{
sa1.putel(7, temp);	temp=sa1.getel(7);
cout<<temp;
cout<<"\n\n !Press c to continue or any key to exit."<<endl<<endl;
}while(getch()=='c');
}```

11. Registered User
Join Date
Apr 2010
Posts
5
BISMILLAH.

I didnt want to reply as you say but it was necessary after that exercise where can i find the solution i need more of chapter 07 and chapter 10???

12. Registered User
Join Date
Dec 2012
Posts
1
needs operator over loading problem solutions

13. Registered User
Join Date
Feb 2016
Posts
1
Your solution to chapter 2 exercise 12 doesn't work. Consider entering £3.55. The correct answer should be £3.11.0. Your solution results in £3.10.11.
My solution below solves this error:

Code:
```#include<iostream>
using namespace std;

int ch1_ex12(){
int pPounds=0,pShillings=0,pPence=0;
float pPencePart;
char pDummy;

cout << "Enter decimal pounds: ";
cin >> pPounds >> pDummy >> pPence;

// get shillings
pShillings = pPence / 5;

// get pence
pPencePart = static_cast<float>(pPence - (pShillings * 5));
pPence = static_cast<float>((pPencePart  / 5) * 12);

// output
cout << "\nEquivalent in old notation = " << '\x9c' << pPounds << "." << pShillings << "." << pPence << "." << endl;

return 0;
}```

#### Posting Permissions

• You may not post new threads
• You may not post replies
• You may not post attachments
• You may not edit your posts
•

 FAQ Latest Articles Java .NET XML Database Enterprise
 Questions? Contact us. C++ Web Development Wireless Latest Tips Open Source