Example: Find the GCF (18, 27)
27 - 18 = 9
18 - 9 = 9
9 - 9 = 0

// Find GCD using while loop
#include <iostream>
using namespace std;

int main()
{
    int n1, n2;

    cout << "Enter two numbers: ";
    cin >> n1 >> n2;
    
    while(n1 != n2)
    {
        if(n1 > n2)
            n1 -= n2;  //n1 = n1-n2
        else
            n2 -= n1; //n2 = n2-n1
    }

    cout << "HCF = " << n1 <<endl;
    return 0;
}

Output
Enter two numbers: 78
52
HCF = 26

 n1=78 , n2=52 
n1>n2     	n1=n1-n2=78-52=26 
n2>n1		n2=n2-n1=52-26=26
n1=n2=hcf

 // Find HCF/GCD using for loop
#include <iostream>
using namespace std;

int main() 
{
    int n1, n2, hcf;
    cout << "Enter two numbers: ";
    cin >> n1 >> n2;

    // Swapping variables n1 and n2 if n2 is greater than n1.
    if ( n2 > n1) 
    {   
        int temp = n2;
        n2 = n1;
        n1 = temp;
     }
    
    for (int i = 1; i <=  n2; ++i) 
    {
        if (n1 % i == 0 && n2 % i ==0) 
{
            	hcf = i;
            }
     }

    cout << "HCF = " << hcf <<endl;
    return 0;
}

// Find LCM
#include <iostream>
using namespace std;

int main()
{
    int n1, n2, max;

    cout << "Enter two numbers: ";
    cin >> n1 >> n2;
    
    // maximum value between n1 and n2 is stored in max
    max = (n1 > n2) ? n1 : n2;

    do
    {
        if (max % n1 == 0 && max % n2 == 0)
        {
            cout << "LCM = " << max <<endl;
            break;
        }
        else
            ++max;
    } while (true);
    
    return 0;
}

Output
Enter two numbers: 12
18
LCM = 36

LCM = (n1 * n2) / HCF

//Find LCM using HCF
#include <iostream>
using namespace std;

int main()
{
    int n1, n2, hcf, temp, lcm;

    cout << "Enter two numbers: ";
    cin >> n1 >> n2;

      //To find hcf on n1 and n2    
    hcf = n1; //use temp variables 
    temp = n2;
    
    while(hcf != temp)
    {
        if(hcf > temp)
            hcf -= temp;
        else
            temp -= hcf;
    }

    lcm = (n1 * n2) / hcf;

    cout << "LCM = " << lcm << endl;
    return 0;
}

// C++ Program to Reverse an Integer
#include <iostream>
using namespace std;

int main()
{
    int n, reversedNumber = 0, remainder;

    cout << "Enter an integer: ";
    cin >> n;

    while(n != 0)
    {
        remainder = n%10;
        reversedNumber = reversedNumber*10 + remainder;
        n /= 10;
    }

    cout << "Reversed Number = " << reversedNumber <<endl;

    return 0;
}

Output
Enter an integer: 12345
Reversed number = 54321

cout << "Enter an integer: ";
cin >> n;

 while(n != 0)

 remainder = n%10;
reversedNumber = reversedNumber*10 + remainder;
n /= 10;

while(n != 0)

cout << "Reversed Number = " << reversedNumber <<endl;

Power of a number = baseexponent

// Compute Power Manually
#include <iostream>
using namespace std;

int main() 
{
    int exponent;
    float base, result = 1;

    cout << “Enter base and exponent respectively:  “;
    cin >> base >> exponent;

    cout << base << “^” << exponent << “ = “;

    while (exponent != 0) {
        result *= base;
        --exponent;
    }

    cout << result <<endl;
    
    return 0;
}

 Output
Enter base and exponent respectively:  3.4
5
3.4^5 = 454.354

// Compute power using pow() Function
#include <iostream>
#include <cmath>

using namespace std;

int main() 
{
    float base, exponent, result;

    cout << “Enter base and exponent respectively:  “;
    cin >> base >> exponent;

    result = pow(base, exponent);

    cout << base << “^” << exponent << “ = “ << result <<endl;
    
    return 0;
}

Output
Enter base and exponent respectively:  2.3
4.5
2.3^4.5 = 42.44

// Print ASCII Value in C++
#include <iostream>
using namespace std;

int main()
{
 char c;
 cout << "Enter a character: ";
 cin >> c;
 cout << "ASCII Value of " << c << " is " << int(c);
 return 0;
}

Output
Enter a character: p
ASCII Value of p is 112

// Check Palindrome Number
#include <iostream>
using namespace std;

int main()
{
     int n, num, digit, rev = 0;

     cout << "Enter a positive number: ";
     cin >> num;

     n = num;

     do
     {
         digit = num % 10;
         rev = (rev * 10) + digit;
         num = num / 10;
     } while (num != 0);

     cout << " The reverse of the number is: " << rev << endl;

     if (n == rev)
         cout << " The number is a palindrome." << endl;
     else
         cout << " The number is not a palindrome." << endl;

    return 0;
}

Output
Enter a positive number: 12321
The reverse of the number is: 12321
The number is a palindrome.

Enter a positive number: 12331
The reverse of the number is: 13321
The number is not a palindrome.

 digit = num % 10;

// Check Prime Number
#include <iostream>
using namespace std;

int main()
{
  int n, i;
  bool isPrime = true;

  cout << "Enter a positive integer: ";
  cin >> n;

  for(i = 2; i <= n / 2; ++i)
  {
      if(n % i == 0)
      {
          isPrime = false;
          break;
      }
  }
  if (isPrime)
      cout << "This is a prime number" <<endl;
  else
      cout << "This is not a prime number" <<endl;

  return 0;
}

Output
Enter a positive integer: 29
This is a prime number.

cout << "Enter a positive integer: ";
  cin >> n;

for(i = 2; i <= n / 2; ++i)
  {
      if(n % i == 0)
      {
          isPrime = false;
          break;
      }
  }

#include<iostream>
using namespace std;

int main ()
{  
    int num, i, count = 0;

    cout << "Enter the number to be checked : ";
    cin >> num;
   
 if (num == 0)
    {
        cout << "\n" << num << " is not prime";
        exit(1);
    }
    else   
    {
            for(i=2; i < num; i++)
                if (num % i == 0)
                    count++;
    }

    if (count > 1)
 	    cout << "\n" << num << " is not prime.";
    else
        cout << "\n" << num << " is prime.";
    return 0;
}

count = 0;

if (num == 0)
    {
        cout << "\n" << num << " is not prime";
        exit(1);
    }

    else   
    {
            for(i=2; i < num; i++)
                if (num % i == 0)
                    count++;
    }

    if (count > 1)
 	    cout << "\n" << num << " is not prime.";
    else
        cout << "\n" << num << " is prime.";

Runtime Test Cases
Case 1 :
Enter the number to be checked : 5
5 is prime.
 
Case 2 :
Enter the number to be checked : 0                                                                                         
0 is not prime.
 
Case 3 :
Enter the number to be checked : 28
28 is not prime.

//1: Display Prime Numbers Between two Intervals
#include <iostream>
using namespace std;

int main()
{
    int low, high, i, flag;

    cout << "Enter two numbers(intervals): ";
    cin >> low >> high;

    cout << "Prime numbers between " << low << " and " << high << " are: ";

    while (low < high)
    {
        flag = 0;

        for(i = 2; i <= low/2; ++i)
        {
            if(low % i == 0)
            {
                flag = 1;
                break;
            }
        }

        if (flag == 0)
            cout << low << " ";

        ++low;
    }
    cout<<endl;

    return 0;
}

//2: Display Prime Numbers When Larger Number is Entered first
#include <iostream>
using namespace std;

int main()
{
    int low, high, flag, temp;
    
    cout << "Enter two numbers(intevals): ";
    cin >> low >> high;

    //swapping numbers if low is greater than high
    if (low > high) {
        temp = low;
        low = high;
        high = temp;
    }
    cout << "Prime numbers between " << low << " and " << high << " are: ";

    while (low < high)
    {
        flag = 0;

        for(int i = 2; i <= low/2; ++i)
        {
            if(low % i == 0)
            {
                flag = 1;
                break;
            }
        }
        if (flag == 0)
            cout << low << " ";

        ++low;
    }
    return 0;
}

// Check Armstrong Number
#include <iostream>
using namespace std;

int main()
{
  int origNum, num, rem, sum = 0;
  cout << "Enter a positive  integer: ";
  cin >> origNum;

  num = origNum;

  while(num != 0)
  {
      rem = num % 10;
      sum += rem * rem * rem;
      num /= 10;
  }

  if(sum == origNum)
    cout << origNum << " is an Armstrong number." <<endl ;
  else
    cout << origNum << " is not an Armstrong number." <<endl ;

  return 0;
}

 Output
Enter a positive integer: 371
371 is an Armstrong number.

// Display Armstrong Number Between Intervals
#include <iostream>
using namespace std;

int main()
{
  int num1, num2, i, num, digit, sum;

  cout << "Enter first number: ";
  cin >> num1;

  cout << "Enter second number: ";
  cin >> num2;

  cout << "Armstrong numbers between " << num1 << " and " << num2 << " are: " << endl;
  for(i = num1; i <= num2; i++)
  {
        sum = 0;
        num = i;

        for(; num > 0; num /= 10)
        {
            digit = num % 10;
            sum = sum + digit * digit * digit;
        }

        if(sum == i)
        {
            cout << i << endl;
        }
  }

  return 0;
}

Output
Enter first number: 100
Enter second number: 400
Armstrong numbers between 100 and 400 are:
153
370
371

// Display all Factors of a Number
#include <iostream>
using namespace std;

int main()
{
    int n, i;

    cout << "Enter a positive integer: ";
    cin >> n;

    cout << "Factors of " << n << " are: " << endl;  
    for(i = 1; i <= n; ++i)
    {
        if(n % i == 0)
            cout << i << endl;
    }

    return 0;
}

 Output
Enter a positive integer: 60
Factors of 60 are: 
1 
2 
3 
4 
5 
6
10 
12 
15 
20 
30 
60

// Simple Calculator using switch statement
# include <iostream>
using namespace std;

int main()
{
    char op;
    float num1, num2;

    cout << "Enter operator either + or - or * or /: ";
    cin >> op;

    cout << "Enter two operands: ";
    cin >> num1 >> num2;

    switch(op)
    {
        case '+':
            cout << num1+num2;
            break;

        case '-':
            cout << num1-num2;
            break;

        case '*':
            cout << num1*num2;
            break;

        case '/':
            cout << num1/num2;
            break;

        default:
            // If the operator is other than +, -, * or /, error message is shown
            cout << "Error! operator is not correct";
            break;
    }

    return 0;
}

Output
Enter operator either + or - or * or divide : -
Enter two operands: 
3.4
8.4
3.4 - 8.4 = -5.0

 /* C++ program to implement simple functions of a calculator*/

#include<iostream>
using namespace std;

int main()
{
   int choice;
   long num1, num2, x;

   //displaying different options
   cout << "Please choose your option:"
           "\n1 = Addition"
           "\n2 = Subtraction"
           "\n3 = Multiplication"
           "\n4 = Division"
           "\n5 = Squares"
           "\n6 = exit"
           "\n\nChoice: ";
   cin >> choice;

   //while loop check whether the choice is in the given range
   while(choice < 1 || choice > 6)
   {
      cout << "\nPlease choose the above mentioned option."
              "\nChoice: ";
      cin >> choice;
   }

   switch (choice)
   {
      //Addition
      case 1:
         cout << "Enter two numbers: \n";
         cin >> num1 >> num2;
         x = num1 + num2;
         cout << "Sum = " << x;
         break;

      //Subtraction
      case 2:
         cout << "Enter two numbers: \n";
         cin >> num1 >> num2;
         x = num1 - num2;
         cout << "Subtraction = " << x;
         break;

      //Multiplication
      case 3:
         cout << "Enter two numbers: \n";
         cin >> num1 >> num2;
         x = num1 * num2;
         cout << "Product = " << x;
         break;

      //Division
      case 4:
         cout << "Enter Dividend: ";
         cin >> num1;
         cout << "Enter Divisor: ";
         cin >> num2;

         //while loop checks for divisor whether it is zero or not
         while(num2 == 0)
         {
            cout << "\nDivisor cannot be zero."
                    "\nEnter divisor once again: ";
            cin >> num2;
         }
         x = num1 / num2;
         cout << "\nQuotient = " << x;
         break;

      //Square
      case 5:
         cout << "Enter any number: \n";
         cin >> num1;
         x = num1 * num1;
         cout << "Square = " << x;
         break;

      case 6:
         return 0;

      default: cout << "\nError";
   }
cout<<endl;

return 0;
}

//1: Program to print half pyramid using *
#include <iostream>
using namespace std;

int main()
{
    int rows;

    cout << "Enter number of rows: ";
    cin >> rows;

	
    for(int i = 1; i <= rows; ++i) // outer loop is responsible for row;
    {
	//print * equal to row number
        for(int j = 1; j <= i; ++j) //inner loop is responsible for column
        {
            cout << "* ";
        }
        cout << "\n"; // give line breaks after ending every rows
    }
    return 0;
}

 //2: Program to print half pyramid a using numbers
#include <iostream>
using namespace std;

int main()
{
    int rows;

    cout << "Enter number of rows: ";
    cin >> rows;

    for(int i = 1; i <= rows; ++i) // outer loop is responsible for row
    {
        for(int j = 1; j <= i; ++j) //inner loop is responsible for columns
        {
            cout << j << " ";
        }
        cout << "\n"; // give line breaks after ending every row 
    }
    return 0;
}

 //3: Program to print half pyramid using alphabets
#include <iostream>
using namespace std;

int main()
{
    char input, alphabet = 'A';

    cout << "Enter the uppercase character you want to print in the last row: ";
    cin >> input;

    for(int i = 1; i <= (input-'A'+1); ++i)
    {
        for(int j = 1; j <= i; ++j)
        {
            cout << alphabet << " ";
        }
        ++alphabet;

        cout << endl;
    }
    return 0;
}

//4: Inverted half pyramid using *
#include <iostream>
using namespace std;

int main()
{
    int rows;

    cout << "Enter number of rows: ";
    cin >> rows;

    for(int i = rows; i >= 1; --i)
    {
        for(int j = 1; j <= i; ++j)
        {
            cout << "* ";
        }
        cout << endl;
    }
    
    return 0;

}

//5: Inverted half pyramid using numbers
#include <iostream>
using namespace std;

int main()
{
    int rows;

    cout << "Enter number of rows: ";
    cin >> rows;

    for(int i = rows; i >= 1; --i)
    {
        for(int j = 1; j <= i; ++j)
        {
            cout << j << " ";
        }
        cout << endl;
    }

    return 0;
}

//6: Program to print full pyramid using *
int main()
{
   int rows, i, j, space;

   cout << "Enter number of rows: ";
   cin >> rows;

   for(i = 1; i <= rows; i++) //i=1,2,3,…..rows
   {
      //for loop for displaying space
      for(space = i; space < rows; space++)
      {
         cout << " "; //spaces=rows-1,rows-2,rows-3,….,0
      }

      //for loop to display stars 
      for(j = 1; j <= (2 * i - 1); j++) // 
      {
         cout << "*";//stars=1,3,5,…,2*row-1
      }

      cout << "\n";
   }

   return 0;
}

//7 : C++ program to display inverted full star pyramid

#include<iostream>
using namespace std;

int main()
{
   int rows, i, j, space;

   cout << "Enter number of rows: ";
   cin >> rows;

   for(i = rows; i >= 1; i--)
   {
      //for loop to put space
      for(space = i; space < rows; space++)
         cout << " ";

      //for loop for displaying star
      for(j = 1; j <= (2 * i - 1); j++)
         cout << "* ";

      cout << "\n";
   }

   return 0;
}

//8 : C++ program to display hollow star pyramid

#include<iostream>
using namespace std;

int main()
{
   int rows, i, j, space;

   cout << "Enter number of rows: ";
   cin >> rows;

   for(i = 1; i <= rows; i++)
   {
      //for loop to put space in pyramid
      for (space = i; space < rows; space++)
         cout << " ";

      //for loop to print star
      for(j = 1; j <= (2 * rows - 1); j++)
      {
         if(i == rows || j == 1 || j == 2*i - 1)
            cout << "*";
         else
            cout << " ";
      }
      cout << "\n";
   }
   return 0;
}

 //9 : C++ program to display inverted hollow star pyramid

#include<iostream>
using namespace std;

int main()
{
   int rows, i, j, space;

   cout << "Enter number of rows: ";
   cin >> rows;

   for(i = rows; i >= 1; i--)
   {
      //for loop to put space in pyramid
      for (space = i; space < rows; space++)
         cout << " ";

      //for loop to print star in pyramid
      for(j = 1; j <= 2 * i - 1; j++)
      {
         if(i == rows || j == 1 || j == 2*i - 1)
            cout << "*";
         else
            cout << " ";
      }
      cout << "\n";
   }
   return 0;
}

//10: Program to print pyramid using numbers
#include <iostream>
using namespace std;

int main()
{
    int rows, count = 0, count1 = 0, k = 0;

    cout << "Enter number of rows: ";
    cin >> rows;

    for(int i = 1; i <= rows; ++i)
    {
        for(int space = 1; space <= rows-i; ++space)
        {
            cout << "  ";
            ++count;
        }

        while(k != 2*i-1)
        {
            if (count <= rows-1)
            {
                cout << i+k << " ";
                ++count;
            }
            else
            {
                ++count1;
                cout << i+k-2*count1 << " ";
            }
            ++k;
        }
        count1 = count = k = 0;

        cout << endl;
    }
    return 0;
}

//11: Print Pascal's triangle
#include <iostream>
using namespace std;

int main()
{
    int rows, coef = 1;

    cout << "Enter number of rows: ";
    cin >> rows;
//for loop continues till the number of rows entered by the user
    for(int i = 0; i < rows; i++)
    {
//for loop to print required number of space
        for(int space = 1; space <= rows-i; space++)
            cout <<"  ";
//for loop to print number in triangle
        for(int j = 0; j <= i; j++) 
        {
//first and last value of every row is 1
            if (j == 0 || i == 0)
                coef = 1;
            else
                coef = coef*(i-j+1)/j;

            cout << coef << "   ";
        }
        cout << endl;
    }

    return 0;
}

for(int space = 1; space <= rows-i; space++)
            cout <<"  ";

     for(int j = 0; j <= i; j++)
        {
            if (j == 0 || i == 0)
                coef = 1;
            else
                coef = coef*(i-j+1)/j;

            cout << coef << "   ";
        }

//12: Print Floyd's Triangle.
#include <iostream>
using namespace std;

int main()
{
    int rows, number = 1;
//number of rows to print
    cout << "Enter number of rows: ";
    cin >> rows;

//for loop responsible for number of rows
    for(int i = 1; i <= rows; i++)
    {
//for loop responsible for number of columns
        for(int j = 1; j <= i; ++j)
        {
            cout << number << " "; //print number starting from 1
            ++number;
        }

        cout << endl;
    }

    return 0;
}

// parts.cpp
// uses parts inventory to demonstrate structures
#include <iostream>
using namespace std;
////////////////////////////////////////////////////////////////
struct part 		//1- declare a structure
{
int modelnumber; 	//ID number of widget
int partnumber;	//ID number of widget part
float cost; 		//cost of part
};
////////////////////////////////////////////////////////////////
int main()
{
part part1; 	//2- define a structure variable

part1.modelnumber = 6244; 		//3- give values to structure members
part1.partnumber = 373;
part1.cost = 217.55F;

//4- display structure members
cout << “Model “ << part1.modelnumber;
cout << “, part “ << part1.partnumber;
cout << “, costs $” << part1.cost << endl;
return 0;
}

Model 6244, part 373, costs $217.55

 struct part
{
int modelnumber;
int partnumber;
float cost;
};

 part part1;

 part part1;
int var1;

 part1.modelnumber = 6244;

cout << “\nModel “ << part1.modelnumber;

// partinit.cpp
// shows initialization of structure variables
#include <iostream>
using namespace std;
////////////////////////////////////////////////////////////////
struct part		 //specify a structure
{
int modelnumber; 	//ID number of widget
int partnumber;	 //ID number of widget part
float cost; 		//cost of part
};
////////////////////////////////////////////////////////////////
int main()
{ 
//initialize variable
part part1 = { 6244, 373, 217.55F };
part part2; //define variable

//display first variable
cout << “Model “ << part1.modelnumber;
cout << “, part “ << part1.partnumber;
cout << “, costs $” << part1.cost << endl;

part2 = part1; //assign first variable to second

//display second variable
cout << “Model “ << part2.modelnumber;
cout << “, part “ << part2.partnumber;
cout << “, costs $” << part2.cost << endl;
return 0;
}

 Model 6244, part 373, costs $217.55
Model 6244, part 373, costs $217.55

 part part1 = { 6244, 373, 217.55 };

part2 = part1;

// englstrc.cpp
// demonstrates structures using English measurements
#include <iostream>
using namespace std;
////////////////////////////////////////////////////////////////
struct Distance //English distance
{
int feet;
float inches;
};
////////////////////////////////////////////////////////////////
int main()
{
Distance d1, d3; 				//define two lengths
Distance d2 = { 11, 6.25 }; 			//define & initialize one length

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

//add lengths d1 and d2 to get d3
d3.inches = d1.inches + d2.inches; 		//add the inches
d3.feet = 0; 					//(for possible carry)
if(d3.inches >= 12.0) 				//if total exceeds 12.0,
{ //then decrease inches by 12.0 
d3.inches -= 12.0; //and
d3.feet++; //increase feet by 1
}
d3.feet += d1.feet + d2.feet; //add the feet

//display all lengths
cout << d1.feet << “\’-” << d1.inches << “\” + “;
cout << d2.feet << “\’-” << d2.inches << “\” = “;
cout << d3.feet << “\’-” << d3.inches << “\”\n”;
return 0;
}

Enter feet: 10
Enter inches: 6.75
10’-6.75” + 11’-6.25” = 22’-1”

d3 = d1 + d2; // can’t do this in ENGLSTRC

struct Room
{
Distance length;
Distance width;
};

 // englarea.cpp
// demonstrates nested structures
#include <iostream>
using namespace std;
////////////////////////////////////////////////////////////////
struct Distance //English distance
{
int feet;
float inches;
};
////////////////////////////////////////////////////////////////
struct Room //rectangular area
{
Distance length; //length of rectangle
Distance width; //width of rectangle
};
////////////////////////////////////////////////////////////////
int main()
{
Room dining; 					//define a room
dining.length.feet = 13; 			//assign values to room
dining.length.inches = 6.5;
dining.width.feet = 10;
dining.width.inches = 0.0;

//convert length & width
float l = dining.length.feet + dining.length.inches/12;
float w = dining.width.feet + dining.width.inches/12;

//find area and display it
cout << “Dining room area is “ << l * w
<< “ square feet\n” ;
return 0;
}

Room dining; // variable dining of type Room

dining.length.feet = 13;

 Dining room area is 135.416672 square feet

Room dining = { {13, 6.5}, {10, 0.0} };

{13, 6.5}

{10, 0.0}

apartment1.laundry_room.washing_machine.width.feet

struct time
{
int hrs;
int mins;
int secs;
};

 time2.hrs = 11;

time time1 = { 11, 10, 59 };

Enter your area code, exchange, and number: 415 555 1212
My number is (212) 767-8900
Your number is (415) 555-1212

// ex4_1.cpp
// uses structure to store phone number
#include <iostream>
using namespace std;
////////////////////////////////////////////////////////////////
struct phone
{
int area; 		//area code (3 digits)
int exchange; 		//exchange (3 digits)
int number; 		//number (4 digits)
};
////////////////////////////////////////////////////////////////
int main()
{
phone ph1 = { 212, 767, 8900 }; 	//initialize phone number
phone ph2;				 //define phone number

// get phone no from user
cout << “\nEnter your area code, exchange, and number”;
cout << “\n(Don’t use leading zeros): “;
cin >> ph2.area >> ph2.exchange >> ph2.number;
cout << “\nMy number is “ 		//display numbers
<< ‘(‘ << ph1.area << “) “
<< ph1.exchange << ‘-’ << ph1.number;
cout << “\nYour number is “
<< ‘(‘ << ph2.area << “) “
<< ph2.exchange << ‘-’ << ph2.number << endl;
return 0;
}

Enter coordinates for p1: 3 4
Enter coordinates for p2: 5 7
Coordinates of p1+p2 are: 8, 11

// ex4_2.cpp
// structure models point on the plane
#include <iostream>
using namespace std;
////////////////////////////////////////////////////////////////
struct point
{
int xCo; 	//X coordinate
int yCo; 	//Y coordinate
};
////////////////////////////////////////////////////////////////
int main()
{
point p1, p2, p3;				 //define 3 points
cout << “\nEnter coordinates for p1: “; 	//get 2 points
cin >> p1.xCo >> p1.yCo; 			//from user
cout << “Enter coordinates for p2: “;
cin >> p2.xCo >> p2.yCo;
p3.xCo = p1.xCo + p2.xCo; 			//find sum of
p3.yCo = p1.yCo + p2.yCo; 			//p1 and p2
cout << “Coordinates of p1+p2 are: “ 	//display the sum
<< p3.xCo << “, “ << p3.yCo << endl;
return 0;
}

 // ex4_3.cpp
// uses structure to model volume of room
#include <iostream>
using namespace std;
////////////////////////////////////////////////////////////////
struct Distance
{
int feet;
float inches;
};
////////////////////////////////////////////////////////////////
struct Volume
{
Distance length;
Distance width;
Distance height;
};
////////////////////////////////////////////////////////////////
int main()
{
float l, w, h;
Volume room1 = { { 16, 3.5 }, { 12, 6.25 }, { 8, 1.75 } };
l = room1.length.feet + room1.length.inches/12.0;
w = room1.width.feet + room1.width.inches /12.0;
h = room1.height.feet + room1.height.inches/12.0;
cout << “Volume = “ << l*w*h << “ cubic feet\n”;
return 0;
}

// table.cpp
// demonstrates simple function
#include <iostream>
using namespace std;

void starline();		 //function declaration
// (prototype)

int main()
{
starline(); 				//call to function
cout << “Data type Range” << endl;
starline(); 				//call to function
cout << “char -128 to 127” << endl
        << “short -32,768 to 32,767” << endl
                     << “int System dependent” << endl
                     << “long -2,147,483,648 to 2,147,483,647” << endl;
           starline();         				 //call to function
return 0;
}
//--------------------------------------------------------------
// starline()
// function definition
void starline() //function declarator
{
for(int j=0; j<45; j++) //function body
cout << ‘*’;
cout << endl;
}

*********************************************
Data type Range
*********************************************
char -128 to 127
short -32,768 to 32,767
int System dependent
long -2,147,483,648 to 2,147,483,647
*********************************************

 void starline();

starline();

void starline() 			//declarator
{
for(int j=0; j<45; j++) /	/function body
cout << ‘*’;
cout << endl;
}

ch = getche();

// table2.cpp
// demonstrates function definition preceding function calls
#include <iostream>
using namespace std; //no function declaration
//--------------------------------------------------------------
// starline() //function definition
void starline()
{
for(int j=0; j<45; j++)
cout << ‘*’;
cout << endl;
}
//--------------------------------------------------------------
int main() //main() follows function
{
starline(); //call to function
cout << “Data type Range” << endl;
starline(); //call to function
cout << “char -128 to 127” << endl
       << “short -32,768 to 32,767” << endl
       << “int System dependent” << endl
       << “long -2,147,483,648 to 2,147,483,647” << endl;
starline(); //call to function
return 0;
}

// tablearg.cpp
// demonstrates function arguments
#include <iostream>
using namespace std;

void repchar(char, int); 	//function declaration

int main()
{
repchar(‘-’, 43); 				//call to function
cout << “Data type Range” << endl;
repchar(‘=’, 23); 				//call to function
cout << “char -128 to 127” << endl
        << “short -32,768 to 32,767” << endl
        << “int System dependent” << endl
        << “double -2,147,483,648 to 2,147,483,647” << endl;
repchar(‘-’, 43); 				//call to function
return 0;
}
//--------------------------------------------------------------
// repchar()
// function definition
void repchar(char ch, int n) 		//function declarator
{
for(int j=0; j<n; j++) 		//function body
cout << ch;
cout << endl;
}

void repchar(char, int); 	// declaration specifies data types

 repchar(‘-’, 43); 	// function call specifies actual values

repchar(‘=’, 23);

 -------------------------------------------
Data type Range
=======================
char 	-128 to 127
short 	-32,768 to 32,767
int 	System dependent
long	 -2,147,483,648 to 2,147,483,647
-------------------------------------------

 void repchar(char ch, int n) 	//declarator specifies parameter
//names and data types

char ch;
int n;

// vararg.cpp
// demonstrates variable arguments
#include <iostream>
using namespace std;

void repchar(char, int); 	//function declaration

int main()
{
char chin;
int nin;

cout << “Enter a character: “;
cin >> chin;
cout << “Enter number of times to repeat it: “;
cin >> nin;

repchar(chin, nin);
return 0;
}
//--------------------------------------------------------------
// repchar()
// function definition
void repchar(char ch, int n) //function declarator
{
for(int j=0; j<n; j++) //function body
cout << ch;
cout << endl;
}

Enter a character: +
Enter number of times to repeat it: 20
++++++++++++++++++++

repchar(chin, nin); // function call

// convert.cpp
// demonstrates return values, converts pounds to kg
#include <iostream>
using namespace std;

float lbstokg(float); //declaration

int main()
{
float lbs, kgs;
cout << “\nEnter your weight in pounds: “;
cin >> lbs;
kgs = lbstokg(lbs);
cout << “Your weight in kilograms is “ << kgs << endl;
return 0;
}
//--------------------------------------------------------------
// lbstokg()
// converts pounds to kilograms
float lbstokg(float pounds)
{
float kilograms = 0.453592 * pounds;
return kilograms;
}

Enter your weight in pounds: 182
Your weight in kilograms is 82.553741

float lbstokg(float);

kgs = lbstokg(lbs);

 return kilograms;

somefunc(); // declaration -- assumes return type is int

 // convert2.cpp
// eliminates unnecessary variables
#include <iostream>
using namespace std;

float lbstokg(float); 		//declaration

int main()
{
float lbs;

cout << “\nEnter your weight in pounds: “;
cin >> lbs;
cout << “Your weight in kilograms is “ << lbstokg(lbs)
        << endl;
return 0;
}
//--------------------------------------------------------------
// lbstokg()
// converts pounds to kilograms
float lbstokg(float pounds)
{
return 0.453592 * pounds;
}

cout << “Your weight in kilograms is “ << lbstokg(lbs) << endl;

 return 0.453592 * pounds;

return (0.453592 * pounds);