Divide and Conquer

Most computer programs that solve real-world problems are much larger than the short, simple program examples that you find in your textbooks or on this web site. The best way to develop and maintain these larger programs is to modularize them - that is, to divide the overall problem into a number of smaller pieces that are more easily managed.

Function Categories

In C++, these modules are called functions and classes. C++ programmers create programs by combining new programmer-defined functions with a number of pre-defined functions from the C++ standard library and by combining new programmer-defined classes with pre-defined classes available from a variety of class libraries.

The two catagories of C++ functions are illustrated below. They include Library Functions from the C++ Standard Library and Programmer-Defined Functions that are custom functions written to satisfy a particular need.

The diagram below illustrates the organization of C++ functions. Note that Library Functions are also called built-in functions. Under Programmer-Defined Functions we have functions that do not return a value (labeled Just Do IT!), functions that return a value, and functions that modify variable values from the calling function. More about all of these in other sections of this page.

Function Syntax

A function is a group of statements that is executed when it is called (invoked) from some point in the program. The following is the basic function syntax:

type name ( parameter1, parameter2, ...) 
{ 
  statements 
}

• type is the data type specifier of the data to be returned by the function.
• name is the identifier by which it will be possible to call (invoke) the function.
• parameter1, parameter2, ... (as many as needed): Each parameter consists of a data type specifier followed by an identifier, like any regular variable declaration (for example: int x) and which acts within the function as a regular local variable. They allow you to pass arguments to the function when it is called. The different parameters are separated by commas.
• statements is the function's body. It is a block of statements surrounded by braces { }.

Below is an example of a C++ function that calculates the area of a triangle and is illustrative of the basic function syntax.

float triangle(float base, float height)
{
  float area;           // area of the triangle 

  area = base * height / 2.0;
  return (area);
}

Function Placement

Functions may appear anywhere in your program. However, the organization shown below is recommended.

	Begin with the usual #include compiler directives that specify the libraries that you need (e.g., iostream). Also include all global declarations and function prototypes.
	You must include the main() function. It can include delclarations for local variable.
	Programmer-defined function definitions follow the main() function.
	You may include multiple programmer-defined functions in your programs.

Here is a simple C++ program that uses the function above to find the area of three triangles, given the base and the height as part of the function calls:

#include <iostream.h>

using namespace std; 

// function prototype (declaration) 
float triangle(float base, float height);   

int main(void) 
{
  cout << "Triangle #1 " << triangle(1.3, 8.3) << endl;
  cout << "Triangle #2 " << triangle(4.8, 9.8) << endl;
  cout << "Triangle #3 " << triangle(1.2, 2.0) << endl;
  return (0);
}

// triangle -- compute area of a triangle 
// 
// Parameters passed
//   width -- base of the triangle 
//   height -- height of the triangle 
// 
// Returns 
//   area of the triangle 
float triangle(float base, float height)
{
  float area;           // area of the triangle 

  area = base * height / 2.0;
  return (area);
}

When compiled (using g++) and run on the class server (by typing ./triangle at the prompt), the program above produces the following output:

et791:~/cset3150$ ./triangle 
Triangle #1 5.395
Triangle #2 23.52
Triangle #3 1.2
et791:~/cset3150$ _

Copy this example to your directory on the class server and try it!

Variations on a Theme

Here is another function. This one accepts three numbers of type double and returns the largest (max) of the three.

double maximum( double x, double y, double z )
{
   double max = x;   // assume x is largest

   if ( y > max )    // if y is larger,
   {
      max = y;       // assign y to max
   }

   if ( z > max )    // if z is larger,
   {
      max = z;       // assign z to max
   }

   return max;       // max is largest value
} 

The function above is written in compliance with the coding standards described elsewhere on this website. It is also correct C++ syntax to write it as follows:

double maximum( double x, double y, double z )
{
   double max = x; 

   if ( y > max )  max = y; 
   if ( z > max )  max = z;

   return max;
} 

The C++ program below uses the function above to accept three numbers from the user (at the keyboard) and then return the maximum.

// Finding the maximum of three floating-point numbers
#include <iostream>

using std::cout;
using std::cin;
using std::endl;

// function prototype
double maximum( double, double, double ); 

int main()
{
   double number1;
   double number2;
   double number3;

   cout << "Enter three floating-point numbers: ";
   cin >> number1 >> number2 >> number3;

   // number1, number2 and number3 are arguments to 
   // the maximum function call
   cout << "Maximum is: " 
        << maximum( number1, number2, number3 ) << endl;

   return 0;  // indicates successful termination
} 

// function maximum definition
// x, y and z are parameters
double maximum( double x, double y, double z )
{
   double max = x;

   if ( y > max )
   {
      max = y;
   }

   if ( z > max )
   {
      max = z;
   }

   return max;
} 

In the program above there are some interesting syntax variations that you should notice. First, the using namespace std; statement has been replaced with the following:

using std::cout;
using std::cin;
using std::endl;

   std::cout << "Enter three floating-point numbers: ";
   std::cin >> number1 >> number2 >> number3;

// function prototype
double maximum( double, double, double ); 

When run on the class server, this program produces the following interactive output:

et791:~/cset3150$ ./maximum 
Enter three floating-point numbers: 7.86 4.11111 3.25 
Maximum is: 7.86
et791:~/cset3150$ _

et791:~/cset3150$ ./maximum 
Enter three floating-point numbers: 6.89 
2.44 
27.1 
Maximum is: 27.1
et791:~/cset3150$ _

To Return or Not to Return

In C++, functions are of two types: those that return a value and those that simply "do something." The following two examples illustrate this difference.

#include <iostream> 
using namespace std; 

int square(int i); 

int main(void) 
{ 
    int num; 
    int sq; 
    cout << "Please enter a number: "; 
    cin >> num; 
    sq = square(num); 
    cout << "Square of " << num << " is " << sq; 
    return 0; 
} 

int square(int i) 
{ 
    int sq = i * i; 
    return sq; 
} 

When you require a result from a function (e.g., square root, difference between two numbers, a string that is combined from two other strings, etc.), return a result. When you don't, then return void.

#include <iostream> 
using namespace std; 

void square(int i); 

int main(void) 
{ 
    int num; 
    cout << "Please enter a number: "; 
    cin >> num; 
    square(num); 
    return 0; 
} 

void square(int i) 
{ 
    int sq = i * i; 
    cout << "Square of " << i << " is " << sq; 
} 

There have been visitors to date.