5. Functions

As with most other programming languages, C++ also has the concept of functions, which are named reusable code blocks. They can take any number of parameters to send data into the function. Functions can then return a result to the calling block. Functions exist to perform a specific task within the construct of a larger program. As you use functions within your programs, two fundamental concepts exist:

1. Defining (declaring) the function. This provides the function’s definition: the name, parameters, and functionality. Unlike Python, you will need to explicitly define functionʼs return type and parameter.  A function’s name, the return type, and the parameter types determine the function’s signature.  Many consider the four parts of a function to be the name, return type, parameters, and the function body.

2. Calling the function. As we call (execute) a function, we pass a specific list of arguments as the values for a function’s parameters. C++ uses the follow syntax to define a function:

returnType functionName(parameterList) {
    functionBody
}

Unlike Python, you must define both the parameter type and the name. Parameters are separated by commas. In C++, if your function does not return a value, you should declare the function to return void. Otherwise, this is considered a compiler warning. If a function does not have any parameters, you can either place the keyword void in between the parenthesis or leave that space blank.

//filename: function.cpp
//complile: g++ -std=c++17 -o function function.cpp
//execute: ./function
#include <iostream>
using std::cout;

int max(int num1, int num2) {
   if (num1 > num2) {
       return num1;
   }
   else {
       return num2;
   }
}

int main(int argc, char *argv[]) {
    int num1 = 122, num2 = 22;
    int result = max(num1,num2);
    cout << "Maximum of (" << num1 << ", " << num2 << "): " << result << "\n";
}

Visualize execution

5.1. Passing Parameters

By default, C++ passes parameters to functions by value. In other words, a copy of a value is placed in the stack frame for the called object. Without using pointers or references, any changes made to a parameter are limited to the scope of that function. The following incorrect implementation of swap demonstrates _call by value _in that a and b remain unchanged after the call to swap.

//filename: badswap.cpp
//complile: g++ -std=c++17 -o badswap badswap.cpp
//execute: ./badswap
#include <iostream>
using std::cout;

void swap(int a, int b) {
    int t = a;
    a = b;
    b = t;
    cout << "in swap: (a, b) = (" << a << ", " << b << ")" << "\n";
}

int main() {
    int a = 10;
    int b = 15;
    cout << "before swap: (a, b) = (" << a << ", " << b << ")" << "\n";
    swap(a,b);
    cout << "after swap: (a, b) = (" << a << ", " << b << ")" << "\n";
}

The following code prints the address of the variable a - this demonstrates that a is a different object is a different object between main and bad implementation of swap. Remember, that in C++, an object is “a region of data storage in the execution environment, the contents of which can represent values”. The address points (refers) to that data storage in memory. The unary operator & is called the “address-of” operator. This operator provides the address of a variable in memory address. These addresses returned by the address-of operator are known as pointers because they “point” to the variable in memory.The address-of operator can only be applied to lvalues.

//filename: swap_address.cpp
//complile: g++ -std=c++17 -o swap_address swap_address.cpp
//execute: ./swap_address
#include <iostream>
using std::cout;

void swap(int a, int b) {
    int t = a;
    a = b;
    b = t;
    cout << "in swap: a address " << &a << "\n";
}

int main(int argc, char *argv[]) {
    int a = 10;
    int b = 15;
    cout << "before swap: a address " << &a << "\n";
    swap(a,b);
    cout << "after swap: a address " << &a << "\n";
}

Below, we demonstrate the proper way to pass arguments to a function using C++’s pass-by reference mechanism. We place the “address-of” operator in the function’s parameter definition. Rather than passing the value of the parameter (such as 10 for a), C++ passes the value of a’s address. We can then use the variable as we normally would, and updates are applied to a’s original address - in other words, ais the same object in memory for both main and for swap.

//filename: swap_references.cpp
//complile: g++ -std=c++17 -o swap_references swap_references.cpp
//execute: ./swap_references
#include <iostream>
using std::cout;

void swap(int &a, int &b) {
    int t = a;
    a = b;
    b = t;

    cout << "in swap: a address " << &a << "\n";
    cout << "in swap: (a, b) = (" << a << ", " << b << ")" << "\n";
}

int main() {
    int a = 10;
    int b = 15;

    cout << "before swap: a address " << &a << "\n";
    cout << "before swap: (a, b) = (" << a << ", " << b << ")" << "\n";

    swap(a,b);

    cout << "after swap: a address " << &a << "\n";
    cout << "after swap: (a, b) = (" << a << ", " << b << ")" << "\n";

}

The following code demonstrates the C++ use of call by value and return by value with classes. You can see that C++ copies the return value from squarePoint into p2.

//filename: class_return.cpp
//complile: g++ -std=c++17 -o class_return class_return.cpp
//execute: ./class_return
#include <iostream>
using std::cout;

class point {
public:
    int x;
    int y;
};

point squarePoint(point t) {
    cout << "in call: t address " << &t << "\n";
    point result;
    result.x = t.x * t.x;
    result.y = t.y * t.y;
    cout << "in call: result address " << &result << "\n";
    return result;
}

int main(int argc, char *argv[]) {
    point p;
    
    p.x = 1;
    p.y = 5;

    cout << "(x,y): (" << p.x << ", " << p.y << ")" << "\n";
    point p2;
    cout << "before call: p2 address " <<  &p2 << "\n";
    p2 = squarePoint(p);
    cout << "(x,y): (" << p2.x << ", " << p2.y << ")" << "\n";
    cout << "after call: p2 address " << &p2 << "\n";

    return EXIT_SUCCESS;
}

To avoid copying large objects, we can also use the reference mechanism, but apply the const keyword to prevent any changes to the original object. Often, this can be a good practice to prevent unintended side effects. You should try altering t in squarePoint (e.g., add the line    t.x = 10;) to see how the compiler handles this situation.

//filename: point_const.cpp
//complile: g++ -std=c++17 -o point_const point_const.cpp
//execute: ./point_const
#include <iostream>
using std::cout;

class point {
public:
    int x;
    int y;
};

point squarePoint(const point &t) {
    cout << "in call: t address " << &t << "\n";
    point result;
    result.x = t.x * t.x;
    result.y = t.y * t.y;
    cout << "in call: result address " << &result << "\n";
    return result;
}

int main(int argc, char *argv[]) {
    point p;
    
    p.x = 1;
    p.y = 5;

    cout << "(x,y): (" << p.x << ", " << p.y << ")" << "\n";
    point p2;
    cout << "before call: p address " <<  &p << "\n";
    p2 = squarePoint(p);
    cout << "(x,y): (" << p2.x << ", " << p2.y << ")" << "\n";
    cout << "after call: p2 address " << &p2 << "\n";

    return EXIT_SUCCESS;
}

Note: After attempting to modify t and compiling the program, the compiler should produce the error message “error: assignment of member ‘point::x’ in read-only object”.

5.1.1. Scope

Scope is pretty much the same between C++ and Python. The biggest difference is that once a code block ends for C++, any variable declared within the scope goes out of scope, even if you are still in the same function. You can think that every { } block forms a level of scope, and you can access variables defined by other blocks that enclose that block.

//filename: scope.cpp
//complile: g++ -std=c++17 -o scope scope.cpp
//execute: ./scope
#include <iostream>
using std::cout;

void swap(int a, int b) {
    int t = a;
    a = b;
    b = t;
    cout << "in swap: (a, b) = (" << a << ", " << b << ")" << "\n";
}

int main(int argc, char *argv[]) {
    int a = 10;
    int b = 15;
    cout << "before swap: (a, b) = (" << a << ", " << b << ")" << "\n";
    swap(a,b);
    cout << "after swap: (a, b) = (" << a << ", " << b << ")" << "\n";
    if (1) {
        int a = 33;
        int c = 50;
        cout << "Within if: a=" << a << "\n";
        cout << "Within if: b=" << b << "\n";
        cout << "Within if: c=" << c << "\n";
    }
    cout << "After if: a=" << a << "\n";
    cout << "Value of c: " << c << "\n";  // This line causes a compilation error. 
                                          // Try running to see the error, comment out the line, and run again 
                                          // Note: This is an exeption, to always work top-down with errors
                                          //       However, note that the first message is a warning, not an error.
}

5.1.2. Other Notes

• C++ does support function overloading as long as the parameter types differ. With Python, the second function definition replaces the first definition.

• Function naming rules follow that for variables: must start with a letter or underscore followed by any number of letters, numbers, or underscores.  C++ does not have a universal guideline for function names.  Both camelCase and underscores (as in Python) are used to distinguish words.

• While it will not be covered in this class, functions can have a variable number of arguments in C++. 

• Unlike Python, C++ cannot nest functions.

5.2. Review Questions

1. Compare and constrast functions in Python and C++.

2. Explain how C++ uses call by value. Why did this create issues with the swap function?