---

Subroutines/Functions in C++

---

• Types of functions in C++
  • There are two kinds of functions (just like Java) in C++:

    Member functions that are defined inside a class These functions (always) have an implict (hidden) parameter that has the type of that class Stand-alone functions that are not defined inside any class These functions do not have the implict (hidden) parameter These function are similar to the class methods in Java

    ---

  • We will discuss the stand-alone functions here.

    The member functions are very similar, and they will be introduced later when we discuss classes

    ---

  • Nomenclature:

    Function is used to mean stand-alone functions In fact, the term stand-alone function does not exist in C++ literature I coined it to high-light the difference between a member function and a non-member function A non-member function in C++ is usually called an "ordinary" function

  ---

  ---

• Defining and Declaring Functions
  • Function definition is the creation of a function.

    The function definition contain all the information on a function:

    Its name (how it identify the function) The number and type of parameters (what it needs to do its work) The type of output (return) value produced What does it do (the code of the function)

    ---

  • Example:

    double cube( double x ) { return( x * x * x ); }

    ---

    ---

  • Function declaration is the description of a function

    The description is the information that the C++ compiler need to know in order to translate the program

  • The compiler needs the following information:

    The name of the function (you need to find the function) The number and type of parameters (you need to know how many value and what kind to give the function) The type of output value produced (you need to know what to do with the output - e.g., possible conversion)

    Examples: function declaration

    extern double cube( double ) ; cube() has one parameter extern int myFunc( int, short, double ); myFunc() has three parameters

    NOTE: a function definition encompasses (includes) all information in a function declaration

  ---

  ---

• Functions: some easy and some not so easy
  • In C/C++, you can pass a function as a parameter to a (different) function

  • The way to define and declare function with function parameters is a bit complicated.

  • I will discuss them separately

  ---

  ---

• DEFINING functions that ONLY have VARIABLES as parameters
  • Syntax to DEFINE function with variables as parameters

    ReturnType MySubrName(type1 Var1, type1 Var2, ...) { *** LOCAL Variable definitions *** Subroutine Body (statements) }

  • Example:

    Function Definition: float Square(float x) // Function definition { // float y; // Has all the information // on the function: y = x * x; // return(y); // name, parameters, output } // what to do (body) Using (invoking) a function: int a; short b; b = Square(a); // Will cause conversion !!

    • Since the Square function is called with a int type variable, compiler will convert the type to float before passing it to the function (type conversion = use different encoding)

    • The return(...) statement causes the function to return to the caller (location where the function was called) and the returned value is equal to the expression (...)

      Note that if the type of the expression (...) if different from float (which is the type of value that the function WILL return), the type of expression (...) will first be converted to float before the value is returned !

    • Since the output of the Square function is assigned to a short type variable, compiler will convert the float return type to short before assigning it to b

  • Example Program: (Demo above code) --- click here                        

  ---

  ---

  ---

  ---

• The MAIN function
  • The main program in C/C++ is also a function

  • This MAIN function must be called "main" and it must have 2 parameter (one integer and one array of strings) and it must return an integer:

    int main(int param1, char *param2[]) { MAIN PROGRAM }

    • Param1 is an integer
    • Param2 is an array of character strings (just believe it...)
    • The main() function returns an error code that indicate to the "SHELL" (your console window) whether the program ended succesfully

  • Example Program: (Demo main function) ---                        
    • Here is a MAIN function that prints all its arguments and returns an error code: click here

    • Here is a SHELL SCRIPT that runs "a.out" and depending on the error code, will print "OK" (when error code = 0) or the value of the error code: click here

  ---

• DECLARING functions that ONLY have VARIABLES as parameters
  • Subroutine Declaration Syntax

    extern RetType MySubrName(type1 [Variable1], type1 [Variable2], ...); Things in [ ] brackets are OPTIONAL items Thus: the name of the variables are optional in the function declaration

    Note

    • the keyword extern is required in the ANSI C/C++ standard, but many C/C++ compiler will accept a syntax without the keyword extern

      To make certain that your program will compile on as many platforms as possible, stick to ANSI C/C++ standard.

    • The above definition is kinda verbose; but it only declares ONE single symbolic name which is MySubrName

    ---

  • Example:

    extern float Square(float x); // Function declaration OR: extern float Square(float); // Function declaration int a; short b; b = Square(a); // Conversion !!

    • Through the function declaration:

         extern float Square(float x);
      OR
         extern float Square(float); 

      the C++ compiler now knows that the symbolic name Square is a function that must be called with an float type variable (the name of the variable is no important at all, the type of value (and the value itself) is all what is needed).

      The compiler also knows that the function will return a float type output value.

    • Hence, because the function is given an int type value, the compiler knows that it must first convert the int type to float before passing it to the function

    • And similarly, the float output of the Square function that is assigned to a short type variable, will be converted to short before assigning it to b

    ---

  • Example using function declaration (using separate files)

    // Function is defined // in this file float Square(float x) { float y; y = x * x; return( y ); }

    // Function declaration extern float Square(float); int main(int param1, char *param2) { int a = 4; short b; b = Square(a); cout << " a = " << a; cout << " b = " << b << "\n"; }

    ---

  • Example Program: (Demo function declaration) ---            
    • This is the C++ Square function definition: click here
    • This is the C++ MAIN function definition: click here
    • Compile with: CC C-subroutine2a.C C-subroutine2b.C

    • Experiment: try "lying" to the compiler: change the declaration of "Square"

      C++ will catch your lie and prevent a successful compilation

    ---

    Difference between C and C++

    ---

  • Example Program: (Demo problems in function declaration in C) ---            
    • This is the C Square function definition: click here
    • This is the C MAIN function definition: click here
    • Compile with: cc C-subroutine2a.c C-subroutine2b.c

    • Notice the function declaration is a "lie"

      The C compiler is not as careful as the C++ (type checking is better in C++) and does NOT catch your lie...

      Try running the problem and see the problem...

  ---

  ---

• DEFINING a function that has a FUNCTION as PARAMETER ...

  • Suppose we want to define a function RectangleRule_Prec(f, a, b, EPS) that find an approximation for the definite integral of a function f between the interval (a, b) with accuracy EPS:

  • The input parameters are:

    f: a function: the function to be integrated a: variable: start of integration interval b: variable: end of integration interval EPS: variable: accuracy

    Notice that the parameter f is a function !!!

    ---

  • To specify the function parameter f, we must provide:

    a name of the function (this is a "formal" parameter) the type of its return value and the number and the type of each of its parameters

    Example:

    float RectangleRule_Prec(float h(float), float a, float b, float EPS) { ... }

    • h = name of the function parameter.

      NOTE: This name need NOT be the SAME name of the actual function that you will use in the function call.

      (The name h is just a name that the program uses to refer to the parameter of the function RectangleRule_Prec

    • float (before h ) tells the compiler that the type of the return value of h is float

    • (float) (between ()) tells the compiler that h has one single float type value as parameter

    ---

    ---

  • PROGRAMMING NOTE:

    You may specify names for the parameters of the function parameter; but they will be ignored by the C/C++ compiler

    Example:

    float RectangleRule_Prec(float f(float x ), float a, float b, float EPS) { ... }

    The name x will be ignored by the compiler.

  ---

• DECLARING a function that has a FUNCTION as PARAMETER ...
  • If we want to use the function RectangleRule_Prec(f, a, b, EPS) we may need to declare it first.

  • To DECLARE a function that has another function as parameter we must specify
    1. the type of its return value and
    2. the type of each of its parameters between brackets (separated by commas)

    Example:

    extern float RectangleRule_Pred(float (float), float, float, float);

    • OK, you may be laughing at the funny looking "float (float)" thing... :-)

      NOTICE that the function name is missing

    • This is NO need mention the name of the actual function that you will use...

    • All the compiler need to know is

      how many parameters the function takes, the type of each parameter and the type of the value returned by the function

      ---

    • Hence:

      float(float) tells the compiler that

      The function has ONE parameter The parameter of the function is a float value The function returns a float value as result.

    ---

  • PROGRAMMING NOTE:

    extern float RectangleRule_Pred(float (float), float, float, float);

    Notice that a Function DECLARATION does NOT have curly braces "{" and "}" and MUST be terminated by a semi-colon (;)

    WRONG SYNTAX: extern float RectangleRule_Pred(float (float), float, float, float) { <---- No braces !!! ... } <---- No braces !!!

    ---

  • PROGRAMMING NOTE:
    You may specify the name of the function and the parameters ; they will be IGNORED by the C/C++ compiler:

    extern float RectangleRule_Pred(float h(float y), float a, float b, float EPS);

    (just like in the Function DEFINITION (See: click here )),

    I recommend you use this feature - a lot easier to read !!!

    ---

  • PROGRAMMING NOTE:
    The ANSI C/C++ standard requires the use of the keyword extern.

    But some C/C++ compilers do not need this keyword.

    Again, I recomment that you use it....

  ---

  ---

• Passing a subsroutine/function to another subroutine/function

  • The final point that you need to know is how to call a function with a function as parameter

  • You a function as parameter by giving ONLY the name of the function (without any parameters !)

    ---

  • Example:

    int main(int argc, char *argv[]) { extern float RectangleRule_Pred(float h(float x), float, float, float); extern float f(float x); extern float g(float x); float result1, result2; .... result1 = RectangleRule_Pred(f, 1.0, 2.0, 0.0001); result2 = RectangleRule_Pred(g, 7.0, 9.0, 0.0001);

    ---

  • OK, we are ready to see some real examples of function (and loops and if-statements)...