CIS-62 Home http://www.c-jump.com/CIS62/CIS62syllabus.htm

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>
  
      void main()
      {
          double result = sqrt( 1234.5 );
      }

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 
void main( )
{
    char ch = 'A';
    int result = isalpha( ch );
}

Function parameters

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

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

• 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;
}

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

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>
  char heads( bool value )
  {
      if ( value == true )
          return 'H';
      return tolower( tails( value ) ); // *** does not compile!
  }
  char tails( bool value )
  {
      if ( value == false ) {
          return 'T';
      }
      return tolower( heads( value ) );
  }
  void main( )
  {
      std::cout << heads( true );  // prints H
      std::cout << heads( false ); // prints t
      std::cout << tails( true );  // prints h
      std::cout << tails( false ); // prints T
  }
  
  

Solution: function declarations (prototypes)

#include <iostream>
char heads( bool value );   // function declarations
char tails( bool value );

char heads( bool value )    // function definitions
{
    if ( value == true )
        return 'H';
    return tolower( tails( value ) );
}

char tails( bool value )
{
    if ( value == false ) {
        return 'T';
    }
    return tolower( heads( value ) );
}

void main( )
{
    std::cout << heads( true );  // prints H
    std::cout << heads( false ); // prints t
    std::cout << tails( true );  // prints h
    std::cout << tails( false ); // prints T
}

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