Programmer-Defined Functions

Overview

Functions are among the most important pieces of programming. In fact, the paradigm of programming that this site presents in known as procedural programming. Procedures are functions. Unfortunately, advances in programming development have taken the term functional programming and has provided a more technical meaning. Functions are a way for programs and programmers to modularize code. Functions provide a way to call on a set of actions through a trigger word (a function name).

Functions have a header and then a body. We will go into a bit of detail and be ready to note differences between the three similar languages and Python.

returnType functionName(parameterList) {
  //function body
}

Let's go through the elements:

returnType
Functions must declare if the caller to the function needs to expect anything from the function or not. We will talk about void vs. value returning later
functionName
The name of the function is the verb that allows the function body's code to be executed.
parameterList
The parameter list is the set of no, one, or multiple variables that the function definition expects to receive when it is called. As we go through demonstrations, you will see how these work together to make functions work.

Functions that are programmer-defined are intended to be called as well. To call the function, the name of the function and the type of argument the function is required to have are requisite to have the function operating as expected. Functions are always called from other functions. Always remember that we are always running a main function. In Python we will create our main in order to distinguish our other supportive functions.

Void Functions

Void functions are the simplest types of function to define. They operate on the assumption that the body will be executed with nothing to return. Let's use the letter grade program that we worked on in the decision structures page. We will put the decision structure in the function and then see how to make this work.

Language Code
C++ #include <iostream>
using namespace std;

void getLetterGrade(int g){
  if (g >= 90) {
    cout << 'A';
  }
  else if (g >= 80) {
    cout << 'B';
  }
  else if (g >= 70) {
    cout << 'C';
  }
  else if (g >= 60) {
    cout << 'D';
  }
  else {
    cout << 'F';
  }
}

 int main(){
  int grade;
  cout << "Enter final grade: ";
  cin >> grade;
  cout << "Your final grade is ";
  getLetterGrade(grade);
 }
C# using System;
namespace Grade{
  class GradingProgram {
    static void getLetterGrade(int g){
      if (g >= 90) {
        Console.WriteLine("A");
      }
      else if (g >= 80) {
        Console.WriteLine("B");
      }
      else if (g >= 70) {
        Console.WriteLine("C");
      }
      else if (g >= 60) {
        Console.WriteLine("D");
      }
      else {
        Console.WriteLine("F");
      }
    }

     static void Main(string[] args){
      int grade;
      Console.WriteLine("Enter final grade: ");
      grade = int.Parse(Console.ReadLine());
      Console.WriteLine("Your final grade is");
      getLetterGrade(grade);
     }
  }
}
Java import java.util.Scanner;
public class Grade{
  public static void getLetterGrade(int g){
    if (g >= 90) {
      System.out.println("A");
    }
    else if (g >= 80) {
      System.out.println("B");
    }
    else if (g >= 70) {
      System.out.println("C");
    }
    else if (g >= 60) {
      System.out.println("D");
    }
    else {
      System.out.println("F");
    }
  }

   public static void main(String[] args){
    Scanner keyIn = new Scanner(System.in);
    int grade;
    System.out.print("Enter final grade: ");
    grade = keyIn.nextInt();
    System.out.print("Your final grade is");
    getLetterGrade(grade);
     }
}
Python def getLetterGrade(g):
  if g >= 90:
    print('A')
  elif g >= 80:
    print('B')
  elif g >= 70:
    print('C')
  elif g >= 60:
    print('D')
  else:
    print('F')

 def main():
  grade = int(input("Enter final score for the class: "))
  print("Your final grade:")
  getLetterGrade(grade)
 main()

Functions are what what we make them. The programmer determines what is required for the function to work. We realize then the in this particular program has a programmer-defined function getLetterGrade that has a parameter g. The parameter is additional data that is being used to navigate the function definition. When we call the function (in main) we have to provide the name of the function and an argument (in this case grade) to satisfy the definition we came up with.

All programming languages begin from main. The more advanced you get, you will style programs with main written first then the other functions afterwards. The main function/method will execute to the function call and then surrender control to the defined function until it is complete and then resume where it left off.

Void functions are strictly for processing actions only.

Vaue-Returning Functions

A value-returning function is one where the goal is to perform some action and deliver a value back to the function that called it. In void functions, we typically see a lot of output statements to end the function because it does not send information back. Value-returning functions send information and thus instead of outputs, we define the function to isolate the important value that we want passed back. Functions should be defined with consideration of the law of least principle that states that a function should only do one major logical task. This means that your function should not try to solve a myriad of problems. Only main has the privilege of doing more than one logic action.

With walue-returning functions we now need to really worry about return types. Return types are the data type of the information that will be given back by the function. When we work on the programming example, we will return char for the letter grade. With return types we also have a return statement in the function body. This is typically the last statement in the definition and ends the function. Multiple return statements are only permitted when decision structures are used in the function definition.

Value-return function calls are allowed to exist anywhere variables can because they hold data. Void functions do not hold data so they are a lot less covert in operation.We have been using functions extensively throughout all the exercises we have done especially in C#, Java, and Python. We used functions like input, print, Console.WriteLine, keyIn.nextInt(), etc.

Let's convert our code on the left to a value returning function.

Language Code
C++ #include <iostream>
using namespace std;

char getLetterGrade(int g){
  if (g >= 90) {
    return 'A';
  }
  else if (g >= 80) {
    return 'B';
  }
  else if (g >= 70) {
    return 'C';
  }
  else if (g >= 60) {
    return 'D';
  }
  else {
    return 'F';
  }
}

 int main(){
  int grade;
  cout << "Enter final grade: ";
  cin >> grade;
  cout << "Your final grade is " <<     getLetterGrade(grade) << endl;
 }
C# using System;
namespace Grade{
  class GradingProgram {
    static char getLetterGrade(int g){
      if (g >= 90) {
        return 'A';
      }
      else if (g >= 80) {
        return 'B';
      }
      else if (g >= 70) {
        return 'C';
      }
      else if (g >= 60) {
        return 'D';
      }
      else {
        return 'F';
      }
    }

     static void Main(string[] args){
      int grade;
      Console.WriteLine("Enter final grade: ");
      grade = int.Parse(Console.ReadLine());
      Console.WriteLine($"Your final grade is {getLetterGrade(grade)}");
     }
  }
}
Java import java.util.Scanner;
public class Grade{
  public static char getLetterGrade(int g){
    if (g >= 90) {
      return 'A';
    }
    else if (g >= 80) {
      return 'B';
    }
    else if (g >= 70) {
      return 'C';
    }
    else if (g >= 60) {
      return 'D';
    }
    else {
      return 'F';
    }
  }

   public static void main(String[] args){
    Scanner keyIn = new Scanner(System.in);
    int grade;
    System.out.print("Enter final grade: ");
    grade = keyIn.nextInt();
    System.out.printf("Your final grade is %c", getLetterGrade(grade));
     }
}
Python def getLetterGrade(g):
  if g >= 90:
    return 'A';
  elif g >= 80:
    return 'B';
  elif g >= 70:
    return 'C';
  elif g >= 60:
    return 'D';
  else:
    return 'F';)

 def main():
  grade = int(input("Enter final score for the class: "))
  print("Your final grade: ", getLetterGrade(grade))
 main()

Programming note: Notice that Python function definitions do not change but only adds a return statement. Also, note that the function call can occur in the output statement or could be assigned to variable to make the output statement a tad easier.

Summary

Programming does not allow functions to be nested. All function are standalone constructs that wait to be called. There are no limits to how many functions can be created amd used. There also no limits on parameters that a function can have. Note that when functions are called, if the function has parameters, the argument values (acutal values from the call) are copied over to the parameters. Functions are the building blocks of programming and will be in existence in classes, advanced programming concepts.