Course List http://www.c-jump.com/bcc/

C++ functions

1. Structured Programming
2. Software Design and Implementation
3. C++ functions
4. Math library functions
5. Character classification
6. Function parameters
7. Function definitions
8. Definition format
9. Problem with function definitions
10. Solution: function declarations (prototypes)
11. Communication between functions
12. return from a void function
13. More terminology
14. C++ Functions and Program Structure

Structured Programming

	shuffle	deal	bet	hit	stand	etc... actions
card suite deck bank hand score dealer player etc... objects	· · × · · · · ·	· · · · × · · ·

Software Design and Implementation

int card;
int suite;
int deck[ 52 ];
double bank;
int hand[ 6 ];
int score;
struct dealer;
struct player;
//etc... 

shuffle( deck );
deal( deck, hand );
bet( 1.00 );
hit( player );
stand();
//etc... 

C++ functions

• C++ program is a set of:
  • variable definitions and
  • functions
• Functions encapsulate computations, for example:
  • main( ) is a top-level entry into program
  • math library functions
  • functions for data input/output
  • functions to validate data
  • algorithm functions: sort, copy, find, etc.

Math library functions

• <cmath> header brings collection of math functions such as:

  
      log( x );    // natural logarithm of x
      pow( x, y ); // x raised to power y
      sin( x );    // trigonometric sine of x
      sqrt( x );   // square root of x
      tan( x );    // trigonometric tangent 
  

• For example:

     #include <cmath>
  
      int main()
      {
          double result = sqrt( 1234.5 );
          return 0;
      }

Character classification and conversion library functions

#include <cctype>
// isalpha(c) non-zero if c is alphabetic, 0 if not 
// isupper(c) non-zero if c is upper case, 0 if not 
// islower(c) non-zero if c is lower case, 0 if not 
// isdigit(c) non-zero if c is digit, 0 if not 
// isalnum(c) non-zero if isalpha(c) or isdigit(c), 0 if not 
// isspace(c) non-zero if c is blank, tab, newline, return, formfeed, vertical tab 
// toupper(c) return c converted to UPPER CASE 
// tolower(c) return c converted to lower case 
int main( )
{
    char ch = 'A';
    int result = isalpha( ch );
    return 0;
}

Function parameters

int square( int x )
{
    return x * x;
}

int main( )
{
    int value = 5;
    int result = square( value );
    return 0;
}

• Demo: download and run this EXE, then click

  • Functions,
    • square( ).

Function definitions

#include <iostream>

int square( int x )
{
    return x * x;
}

void display( int x )
{
    std::cout << x;
}

int main( )
{
    int value = 5;
    int result = square( value );
    display( result );
    return 0;
}

Function definition format

• Each function definition has the form:

  return-type function-name( argument-declarations )
  {
      /* declarations and statements */
  }

• A minimal function is:

  
      void dummy() {}
  

  which does nothing and returns nothing.

• A do-nothing functions sometimes are useful as a place holder during program development.

Problem with function definitions

• Consider:

  
  #include <iostream>
  using std::cout;
  
  void print_b( int count )
  {
      --count; // 6
      if ( count == 0 ) return;
      cout << "b";
      print_a( count );
  }
  
  void print_a( int count )
  {
      --count; // 5 3 1
      if ( count == 0 ) return;
      cout << "a";
      print_n( count );
      return;
  }
  
  void print_n( int count )
  {
      --count; // 4 2 0
      if ( count == 0 ) return;
      cout << "n";
      print_a( count );
      return;
  }
  
  int main( )
  {
      // banana
      int count = 7;
      print_b( count );
      return 0;
  }
  
  

Solution: function declarations (prototypes)

#include <iostream>
using std::cout;

// Function declarations
void print_b( int count );
void print_a( int count );
void print_n( int count );

// Function definitions
void print_b( int count )
{
    --count; // 6
    if ( count == 0 ) return;
    cout << "b";
    print_a( count );
}

void print_a( int count )
{
    --count; // 5 3 1
    if ( count == 0 ) return;
    cout << "a";
    print_n( count );
    return;
}

void print_n( int count )
{
    --count; // 4 2 0
    if ( count == 0 ) return;
    cout << "n";
    print_a( count );
    return;
}

int main( )
{
    // banana
    int count = 7;
    print_b( count );
    return 0;
}

Communication between functions

• Functions can have (optional) input parameters:

      int max_value( int x, int y )
      {
          if ( x > y )
              return x;
          return y;
      }

• return statement is the mechanism for returning a value:
  • return expression;
  • Type of returned value has to agree with the function prototype;
  • The calling function is free to ignore the returned value.

return from a void function

    void display_value( int x )
    {
        if ( x < 0 )
            return;
        std::cout << x;
    }

More terminology

• declaration ( function prototype ):

                  void f();

• definition:

                  void f();
                  void f() { /*function body*/ }

• declaration-definition:

                  void f() { /*function body*/ }

• function signature -
  same as prototype, but no return value used

C++ Functions and Program Structure

• Why use functions ?
  
  

  • Functions break large computing tasks into smaller ones.

  • Functions enable people to build on what others have done,
    instead of starting over from scratch.

  • Functions hide details of operation from other parts of the program