1.

CHAPTER 5FUNCTIONS 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;
const float PI = 3.14159F;

//variable of type float

//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 valuesfor
hours, minutes, and
secondsas 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;}

Programmer&Cracker CS
MyBlog:Blog.Amahdy.com
MyWebsite:www.Amahdy.com
Reply With Quote

2.

12-27-2006, 02:02 PM#17

Amahdy
ComputerScience
Join Date
Oct 2005
Location
Maady
Posts
1,819

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
char
int
long
float

power(double
power(char
power(int
power(long
power(float

n,
n,
n,
n,
n,

int
int
int
int
int

p=2);
p=2);
p=2);
p=2);
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
char
int
long
float

power(double
power(char
power(int
power(long
power(float

n,
n,
n,
n,
n,

int
int
int
int
int

p){
p){
p){
p){
p){

for(int
for(int
for(int
for(int
for(int

ret=1;
ret=1;
ret=1;
ret=1;
ret=1;

p>0;
p>0;
p>0;
p>0;
p>0;

p--)
p--)
p--)
p--)
p--)

ret*=n;
ret*=n;
ret*=n;
ret*=n;
ret*=n;

return
return
return
return
return

ret;}
ret;}
ret;}
ret;}
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.) Youll 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
cout<<"Enter b : "; cin
cout<<"Now a value is :
cout<<"\n\n !Press c to
}while(getch()=='c');

>>a;
>>b; swap(a, b);
"<<a<<" and b value is : "<<b;
continue or any key to exit."<<endl<<endl;

}
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 cant 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";}

Programmer&Cracker CS
MyBlog:Blog.Amahdy.com
MyWebsite:www.Amahdy.com
Reply With Quote

3.

12-27-2006, 02:03 PM#18

Amahdy
ComputerScience
Join Date
Oct 2005
Location
Maady
Posts
1,819

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 poundsshillings-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
<<s.pounds<<c<<s.shillings<<c<<s.pence;}

: \x9c"

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
fraction fadd(fraction a, fraction
fraction fsub(fraction a, fraction
fraction fmul(fraction a, fraction
fraction fdiv(fraction a, fraction

denominator;};
b);
b);
b);
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].denominato
r;
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;