// overload.cpp
// demonstrates function overloading
#include <iostream>
using namespace std;

void repchar(); 		//declarations
void repchar(char);
void repchar(char, int);

int main()
{
repchar();
repchar(‘=’);
repchar(‘+’, 30);
return 0;
}	
//--------------------------------------------------------------
// repchar()
// displays 45 asterisks
void repchar()
{
for(int j=0; j<45; j++) // always loops 45 times
cout << ‘*’; // always prints asterisk
cout << endl;
}
//--------------------------------------------------------------
// repchar()
// displays 45 copies of specified character
void repchar(char ch)
{
for(int j=0; j<45; j++) // always loops 45 times
cout << ch; // prints specified character
cout << endl;
}
//--------------------------------------------------------------
// repchar()
// displays specified number of copies of specified character
void repchar(char ch, int n)
{
for(int j=0; j<n; j++) // loops n times
cout << ch; // prints specified character
cout << endl;
}

*********************************************
=============================================
++++++++++++++++++++++++++++++

 void repchar();

void repchar(char);

void repchar(char, int);

// overengl.cpp
// demonstrates overloaded functions
#include <iostream>
using namespace std;
////////////////////////////////////////////////////////////////
struct Distance //English distance
{
int feet;
float inches;
};
////////////////////////////////////////////////////////////////
void engldisp( Distance ); //declarations
void engldisp( float );

int main()
{
Distance d1; //distance of type Distance
float d2; //distance of type float

//get length d1 from user
cout << “\nEnter feet: “; cin >> d1.feet;
cout << “Enter inches: “; cin >> d1.inches;

//get length d2 from user
cout << “Enter entire distance in inches: “; cin >> d2;
cout << “\nd1 = “;

engldisp(d1); //display length 1
cout << “\nd2 = “;

engldisp(d2); //display length 2
cout << endl;
return 0;
}
//--------------------------------------------------------------
// engldisp()
// display structure of type Distance in feet and inches
void engldisp( Distance dd ) //parameter dd of type Distance
{
cout << dd.feet << “\’-” << dd.inches << “\””;
}
//--------------------------------------------------------------
// engldisp()
// display variable of type float in feet and inches
void engldisp( float dd ) //parameter dd of type float
{
int feet = static_cast<int>(dd / 12);
float inches = dd - feet*12;
cout << feet << “\’-” << inches << “\””;
}

 Enter feet: 5
Enter inches: 10.5
Enter entire distance in inches: 76.5
d1 = 5’-10.5”
d2 = 6’-4.5”

int test() { }
int test(int a) { }
float test(double a) { }
int test(int a, double b) { }

// Error code
int test(int a) { }
double test(int b){ }

	#include <iostream>
	using namespace std;
	
	void display(int);
	void display(float);
	void display(int, float);
	
	int main() {
	
	    int a = 5;
	    float b = 5.5;
	
	    display(a);
	    display(b);
	    display(a, b);
	
	    return 0;
	}
	
	void display(int var) {
	    cout << "Integer number: " << var << endl;
	}
	
	void display(float var) {
	    cout << "Float number: " << var << endl;
	}
	
	void display(int var1, float var2) {
	    cout << "Integer number: " << var1;
	    cout << " and float number:" << var2;
	}

Integer number: 5
Float number: 5.5
Integer number: 5 and float number: 5.5

 	// Program to compute absolute value
	// Works both for integer and float
	
	#include <iostream>
	using namespace std;
	
	int absolute(int);
	float absolute(float);
	
	int main() {
	    int a = -5;
	    float b = 5.5;
	    
	    cout << "Absolute value of " << a << " = " << absolute(a) << endl;
	    cout << "Absolute value of " << b << " = " << absolute(b);
	    return 0;
	}
	
	int absolute(int var) {
	     if (var < 0)
	         var = -var;
	    return var;
	}
	
	float absolute(float var){
	    if (var < 0.0)
	        var = -var;
	    return var;
	}

Absolute value of -5 = 5
Absolute value of 5.5 = 5.5

	int absolute(int var) {
	     if (var < 0)
	         var = -var;
	    return var;
	}

	float absolute(float var){
	    if (var < 0.0)
	        var = -var;
	    return var;
	}

 //factor2.cpp
//calculates factorials using recursion
#include <iostream>
using namespace std;

unsigned long factfunc(unsigned long); //declaration

int main()
{
int n; 				//number entered by user
unsigned long fact;		 //factorial

cout << “Enter an integer: “;
cin >> n;
fact = factfunc(n);

cout << “Factorial of “ << n << “ is “ << fact << endl;
return 0;
}

//-------------------------------------------------------------
// factfunc()
// calls itself to calculate factorials
unsigned long factfunc(unsigned long n)
{
if(n > 1)
return n * factfunc(n-1);	 //self call
else
return 1;
}

	// Factorial of n = 1*2*3*...*n
	
	#include <iostream>
	using namespace std;
	
	int factorial(int);
	
	int main() 
	{
	    int n;
	    cout<<"Enter a number to find factorial: ";
	    cin >> n;
	    cout << "Factorial of " << n <<" = " << factorial(n);
	    return 0;
	}
	
	int factorial(int n) 
	{
	    if (n > 1) 
	    {
	        return n*factorial(n-1);
	    }
	    else 
	    {
	        return 1;
	    }
	}

Enter a number to find factorial: 4
Factorial of 4 = 24

 return num*factorial(num-1);

return num*factorial(num-1);

return num*factorial(num-1);

return 1;

	#include<iostream>
	using namespace std;
	
	int add(int n);
	
	int main()
	{
	    int n;
	
	    cout << "Enter a positive integer: ";
	    cin >> n;
	
	    cout << "Sum =  " << add(n);
	
	    return 0;
	}
	
	int add(int n)
	{
	    if(n != 0)
	        return n + add(n - 1);
	    return 0;
	}

 Enter an positive integer: 10
Sum = 55

// missarg.cpp
// demonstrates missing and default arguments
#include <iostream>
using namespace std;

void repchar(char=’*’, int=45); 		//declaration with
//default arguments
int main()
{
repchar(); 		//prints 45 asterisks
repchar(‘=’);		 //prints 45 equal signs
repchar(‘+’, 30); 	//prints 30 plus signs
return 0;
}
//--------------------------------------------------------------
// repchar()
// displays line of characters
void repchar(char ch, int n) 	//defaults supplied
{				 // if necessary
for(int j=0; j<n; j++) 	//loops n times
cout << ch; 		//prints ch
cout << endl;
}

void repchar(char=’*’, int=45); //declaration

 void repchar(char reptChar=’*’, int numberReps=45);

	// C++ Program to demonstrate working of default argument
	
	#include <iostream>
	using namespace std;
	
	void display(char = '*', int = 1);
	
	int main()
	{
	    cout << "No argument passed:\n";
	    display();
	    
	    cout << "\nFirst argument passed:\n";
	    display('#');
	    
	    cout << "\nBoth argument passed:\n";
	    display('$', 5);
	
	    return 0;
	}
	
	void display(char c, int n)
	{
	    for(int i = 1; i <= n; ++i)
	    {
	        cout << c;
	    }
	    cout << endl;
	}

No argument passed:
*
First argument passed:
#
Both argument passed:
$$$$$

void display(char = '*', int = 1);

void add(int a, int b = 3, int c, int d = 4);

void add(int a, int b = 3, int c, int d);

void add(int a, int b, int c, int d = 4);

 void foo(int x); // declaration (function prototype) -- x is a parameter
 
void foo(int x) // definition (also a declaration) -- x is a parameter
{
}

foo(6); // 6 is the argument passed to parameter x
foo(y+1); // the value of y+1 is the argument passed to parameter x

void foo(int x, int y)
{
}
 
foo(6, 7);

void foo(int x, int y) // x and y are created here
{
} // x and y are destroyed here

#include <iostream>
 using namespace std;

void foo(int y)
{
    cout << "y = " << y << '\n';
}
 
int main()
{
    foo(5); 		// first call
 
    int x = 6;
    foo(x);		 // second call
    foo(x+1); 		// third call
 
    return 0;
}

y = 5
y = 6
y = 7

 #include <iostream>
 using namespace std;
 
void foo(int y)
{
    cout << "y = " << y << '\n';
 
    y = 6;
 
    cout << "y = " << y << '\n';
} // y is destroyed here
 
int main()
{
    int x = 5;
    cout << "x = " << x << '\n';
 
    foo(x);
 
    cout << "x = " << x << '\n';
    return 0;
}

 x = 5
y = 5
y = 6
x = 5

 void addOne(int &ref) // ref is a reference variable
{
    ref = ref + 1;
}

 void addOne(int &ref)
{
    ref = ref + 1;
}
 
int main()
{
    int value = 5;
 
    cout << "value = " << value << '\n';
    addOne(value);
    cout << "value = " << value << '\n';
    return 0;
}

value = 5
value = 6

int min(int x, int y)
{
    return x > y ? y : x;
}
 
int main()
{
    cout << min(5, 6) << '\n';
    cout << min(3, 2) << '\n';
    return 0;
}

inline int min(int x, int y)
{
    return x > y ? y : x;
}

 int main()
{
    cout << (5 > 6 ? 6 : 5) << '\n';
    cout << (3 > 2 ? 2 : 3) << '\n';
    return 0;
}

void somefunc()
{
int somevar; 		//variables defined within
float othervar; 	//the function body
// other statements
}

void somefunc()
{
int somevar; 		//local variables
float othervar;
somevar = 10; 		//OK
othervar = 11; 		//OK
nextvar = 12; 		//illegal: not visible in somefunc()
}

void otherfunc()
{
int nextvar; 		//local variable
somevar = 20; 		//illegal: not visible in otherfunc()
othervar = 21; 		//illegal: not visible in otherfunc()
nextvar = 22; 		//OK
}

 int n = 33;

 
// extern.cpp
// demonstrates global variables
#include <iostream>
using namespace std;
#include <conio.h> 		//for getch()

char ch = ‘a’; 			//global variable ch

void getachar(); 		//function declarations
void putachar();

int main()
{
while( ch != ‘\r’ ) 	//main() accesses ch
{
getachar();
putachar();
}
cout << endl;
return 0;
}
//--------------------------------------------------------------
void getachar() 		//getachar() accesses ch
{
ch = getch();
}
//--------------------------------------------------------------
void putachar() 		//putachar() accesses ch
{
cout << ch;
}

 int exvar = 199;

int exvar;

// static.cpp
// demonstrates static variables
#include <iostream>
using namespace std;

float getavg(float); 		//declaration

int main()
{
float data=1, avg;

while( data != 0 )
{
cout << “Enter a number: “;
cin >> data;
avg = getavg(data);
cout << “New average is “ << avg << endl;
}
return 0;
}
//--------------------------------------------------------------
// getavg()
// finds average of old plus new data
float getavg(float newdata)
{
static float total = 0; 		//static variables are initialized
static int count = 0; 		// only once per program
count++; 			//increment count
total += newdata; 		//add new data to total
return total / count; 		//return the new average
}

New average is 10 ← total is 10, count is 1
Enter a number: 20
New average is 15 ← total is 30, count is 2
Enter a number: 30
New average is 20 ← total is 60, count is 3

// replay.cpp
// gets four ages from user, displays them
#include <iostream>
using namespace std;

int main()
{
int age[4]; 			//array ‘age’ of 4 ints

for(int j=0; j<4; j++) 	//get 4 ages
{
cout << “Enter an age: “;
cin >> age[j]; 		//access array element
}

for(j=0; j<4; j++) 		//display 4 ages
cout << “You entered “ << age[j] << endl;
return 0;
}

Enter an age: 44
Enter an age: 16
Enter an age: 23
Enter an age: 68

You entered 44
You entered 16
You entered 23
You entered 68

 cin >> age[j];

 cout << “\nYou entered “ << age[j];

age[j]

// sales.cpp
// averages a weeks’s widget sales (6 days)
#include <iostream>
using namespace std;

int main()
{
const int SIZE = 6; 			//size of array
double sales[SIZE];		 	//array of 6 variables

cout << “Enter widget sales for 6 days\n”;

for(int j=0; j<SIZE; j++) 		//put figures in array
cin >> sales[j];

double total = 0;

for(j=0; j<SIZE; j++) 			//read figures from array
total += sales[j]; 		//to find total
double average = total / SIZE; 	// find average
cout << “Average = “ << average << endl;
return 0;
}

 Enter widget sales for 6 days
352.64
867.70
781.32
867.35
746.21
189.45
Average = 634.11

const int SIZE = 6;

 // days.cpp
// shows days from start of year to date specified
#include <iostream>
using namespace std;

int main()
{
int month, day, total_days;
int days_per_month[12] = { 31, 28, 31, 30, 31, 30,
          31, 31, 30, 31, 30, 31 };

cout << “\nEnter month (1 to 12): “; //get date
cin >> month;

cout << “Enter day (1 to 31): “;
cin >> day;

total_days = day; //separate days

for(int j=0; j<month-1; j++) //add days each month
total_days += days_per_month[j];

cout << “Total days from start of year is: “ << total_days
        << endl;
return 0;
}

Enter month (1 to 12): 3
Enter day (1 to 31): 11
Total days from start of year is: 70

 int days_per_month[] = { 31, 28, 31, 30, 31, 30,
      31, 31, 30, 31, 30, 31 };

// salemon.cpp
// displays sales chart using 2-d array
#include <iostream>
#include <iomanip> //for setprecision, etc.
using namespace std;

const int DISTRICTS = 4;	 //array dimensions
const int MONTHS = 3;

int main()
{
int d, m;
double sales[DISTRICTS][MONTHS]; 		//two-dimensional array
//definition
cout << endl;
for(d=0; d<DISTRICTS; d++)			 //get array values
for(m=0; m<MONTHS; m++)
{
cout << “Enter sales for district “ << d+1;
cout << “, month “ << m+1 << “: “;
cin >> sales[d][m]; 			//put number in array
}

cout << “\n\n”;
cout << “ 					Month\n”;
cout << “ 		1 		2 		3”;

for(d=0; d<DISTRICTS; d++)
{
cout <<”\nDistrict “ << d+1;
for(m=0; m<MONTHS; m++) 		//display array values
cout << setiosflags(ios::fixed)	 //not exponential
        << setiosflags(ios::showpoint)	 //always use point
        << setprecision(2) 		//digits to right
        << setw(10) 			//field width
        << sales[d][m]; 			//get number from array
} //end for(d)

cout << endl;
return 0;
} //end main

double sales[DISTRICTS][MONTHS];

 elem = dimen3[x][y][z];

sales[d][m]

 cout << setiosflags(ios::fixed)		 //fixed (not exponential)
       << setiosflags(ios::showpoint) 		//always show decimal point
       << setprecision(2) 			//two decimal places
       << setw(10) 				//field width 10
       << fpn; 					//finally, the number

// saleinit.cpp
// displays sales chart, initializes 2-d array
#include <iostream>
#include <iomanip> //for setprecision, etc.
using namespace std;

const int DISTRICTS = 4; //array dimensions
const int MONTHS = 3;

int main()
{
int d, m;

//initialize array elements
double sales[DISTRICTS][MONTHS]
= { {   1432.07,       234.50, 	  654.01 },
      {     322.00,   13838.32,  17589.88 },
      {   9328.34,       934.00, 	4492.30 },
      { 12838.29,     2332.63, 	    32.93 } };
cout << “\n\n”;
cout << “ Month\n”;
cout << “ 1 2 3”;

for(d=0; d<DISTRICTS; d++)
{
cout <<”\nDistrict “ << d+1;

for(m=0; m<MONTHS; m++)
cout << setw(10) << setiosflags(ios::fixed)
       << setiosflags(ios::showpoint) << setprecision(2)
       << sales[d][m]; //access array element
}
cout << endl;
return 0;
}

{ 1432.07, 234.50, 654.01 }

// salefunc.cpp
// passes array as argument
#include <iostream>
#include <iomanip> //for setprecision, etc.
using namespace std;

const int DISTRICTS = 4; //array dimensions
const int MONTHS = 3;

void display( double[DISTRICTS][MONTHS] ); //declaration
//--------------------------------------------------------------
int main()
{ //initialize two-dimensional array
double sales[DISTRICTS][MONTHS]
= { {   1432.07,     234.50,     654.01 },
      {     322.00, 13838.32, 17589.88 },
      {   9328.34,     934.00,   4492.30 },
      { 12838.29,   2332.63,     32.93 } };
display(sales); //call function; array as argument
cout << endl;
return 0;
} //end main
//--------------------------------------------------------------
//display()
//function to display 2-d array passed as argument
void display( double funsales[DISTRICTS][MONTHS] )
{
int d, m;
cout << “\n\n”;
cout << “ Month\n”;
cout << “ 1 2 3”;
for(d=0; d<DISTRICTS; d++)
{
cout <<”\nDistrict “ << d+1;

for(m=0; m<MONTHS; m++)
cout << setiosflags(ios::fixed) << setw(10)
        << setiosflags(ios::showpoint) << setprecision(2)
        << funsales[d][m]; //array element
} //end for(d)
} //end display

void display( float[][MONTHS] ); // declaration

 void somefunc( int elem[] ); // declaration

display(sales); // function call