Previous lesson Next lesson

You will remember that a function is supposed to solve a problem: calculate the absolute value of $x$, calculate the greatest common divisor of $m$ and $n$, etc. In some cases, when solving a problem, we will need to, or we could benefit from temporarily storing additional information.

For example, suppose you were asked to implement a function that evaluates a Taylor series of the functions $sin(x)$ and $cos(x)$ around the point $x = 0$. From your Calculus course, you know or will learn that a 10^th-order Taylor series of both sine and cosine are

$sin(x) \approx x - \frac{x^3}{3!} + \frac{x^5}{5!} - \frac{x^7}{7!} + \frac{x^9}{9!}$

where you will note that the first term is $\frac{x^1}{1!}$, and

$sin(x) \approx 1 - \frac{x^2}{2!} + \frac{x^4}{4!} - \frac{x^6}{6!} + \frac{x^8}{8!} - \frac{x^10}{10!}$

where again you will note that the first term is $\frac{x^0}{0!}$.

You are asked to implement these in C++, and while your first implementation is:

double sin_taylor( double x ) {
    return x - x*x*x/6.0            + x*x*x*x*x/120.0
             - x*x*x*x*x*x*x/5040.0 + x*x*x*x*x*x*x*x*x/362880.0;
}

double cos_taylor( double x ) {
    return 1 - x*x/2.0                       + x*x*x*x/24.0
             - x*x*x*x*x*x/720.0             + x*x*x*x*x*x*x*x/40320.0
	     - x*x*x*x*x*x*x*x*x*x/3628800.0;
}

but then you remember Horner's rule, and working hard, you realize that you can simplify this to

double sin_taylor( double x ) {
    return ((((x*x/72.0 - 1.0)*x*x/42.0 + 1.0)*x*x/20.0 - 1.0)*x*x/6.0 + 1.0)*x;
}

double cos_taylor( double x ) {
    return ((((-x*x/90.0 + 1.0)*x*x/56.0 - 1.0)*x*x/30.0 + 1.0)*x*x/12.0 - 1.0)*x*x/2.0 + 1.0;
}

You have reduced the number of multiplications from 45 to 17, so your new functions should be a lot faster; however, you have still calculated x*x nine different times. Wouldn't it be easier to calculate this once, and then to use that calculated value nine times?

For this, we can temporarily store a calculated value in the function and use that value inside the function. The calculated value must be associated with an identifier. That identifier is called a local variable because it is a value that is local to the function.

The way to give a new identifier a value and to then reuse that new value inside a function is as follows:

double sin_taylor( double x ) {
    double xx{x*x};
    return ((((xx/72.0 - 1.0)*xx/42.0 + 1.0)*xx/20.0 - 1.0)*xx/6.0 + 1.0)*x;
}

double cos_taylor( double x ) {
    double xx{x*x};
    return ((((-xx/90.0 + 1.0)*xx/56.0 - 1.0)*xx/30.0 + 1.0)*xx/12.0 - 1.0)*xx/2.0 + 1.0;
}

Just like we specify a parameter by giving the type and its identifier, we must specify the type and identifier of the local variable (in this case, double xx, but we must also give it an initial value, and that initial value appears between two braces:

	type_name identifier{ initial_value };

This is a declaration and initialization of a local variable.

In our function, once the local variable xx is declared and initialized, whenever the identifier xx appears, it will be replaced by the value that xx was initialized to. We have thus reduced the number of multiplications first from 45 down to 17 and now down to 10.

Let us look at a different example. Suppose we want to return the maximum root of a quadratic polynomial that has at least one real root. We will call this function

// Function declarations
double max_root( double a, double b, double c );

We will assume that this polynomial does have at least one real root.

// Function definitions
double max_root( double a, double b, double c ) {
    // Assert that it is not a straight line and
    // that the discriminant is not negative.
    assert( (a != 0) && ((b*b - 4.0*a*c) >= 0.0) );

    return max( (-b + std::sqrt( b*b - 4.0*a*c ))/(2.0*a),
                (-b - std::sqrt( b*b - 4.0*a*c ))/(2.0*a) );
}

You will notice that there are two inefficiencies:

1. we are calculating b*b - 4.0*a*c three times, and
2. we are calculating 2.0*a twice.

Again, it would be nice if we only had to perform these calculations once:

// Function definitions
double max_root( double a, double b, double c ) {
    double two_a{2.0*a};
    double disc{b*b - 4.0*a*c};

    // Assert that it is not a straight line and
    // that the discriminant is not negative.
    assert( (a != 0) && (disc >= 0.0) );

    return max( (-b + std::sqrt( disc ))/two_a,
                (-b - std::sqrt( disc ))/two_a );
}

You will note that we did not call the local variable 2a. Why?

Local variables can be used in many purposes, and their identifiers should help the reader to understand the significance:

    unsigned int count{0};
    double       PI{3.1415926535897932};
    bool         found{false};

The first local variable is counting something, and initially that count is zero, but later as we are counting whatever it is we are counting, we can increase that value. The second local variable is storing the value of $\pi$. The third is a Boolean flag indicating that something has not yet been found, but when what is being searched for, we can set that value to true.

Casting initial values

When you provide an initial value, the compiler will under some circumstances cast the initial value in the type. For example, if you have an integer value initializing a double, the compiler will convert that integer value to a floating-point value. If, however, you attempt to initialize an integer with a floating-point number, the compiler will object, even if that floating-point number is an integer value.

Default initial values

The default initial value of a local variable is 0 or false, as appropriate. You can specify that the local variable be initialized with an initial value by simply using a pair of braces:

    unsigned int count{};        // same as count{0};
    double       sum{};          // same as sum{0.0};
    bool         found{};        // same as found{false};

While this is reasonable to assume, it is, never-the-less easier to specify the initial value, if it is the default. Thus, as a matter of practice, the following is preferred:

    unsigned int count{0};
    double       sum{0.0};
    bool         found{false};

No initial values (uninitialized local variables)

It is possible to not give a local variable an initial value:

    unsigned int count;
    double       sum;
    bool         found;

These variables will be associated with memory somewhere, and if they are not initialized, their values will be based on what was in those memory locations when the function is called. Often, they may be 0 or false, but in general this is almost always a bad idea.

Consider the following program, which you can execute on repl.it.

// Pre-processor include directives
#include <iostream>

// Function declarations
int main();
void with_no_initial_values();

// Function definitions
int main() {
    with_no_initial_values();
    std::cout << "Pi = " << 3.14 << std::endl;
    with_no_initial_values();

    return 0;
}

// Print the values of three local variables,
// none of which are initialized
void with_no_initial_values() {
    int n;
    double x;
    bool b;

   std::cout << n << ", " << x << ", " << b << std::endl;
}

This calls the function with_no_initial_values(), which prints the values of these uninitialized local variables, it then prints a very poor approximation of $\pi$, and then calls the same function again. As you will note, just printing something to the screen causes at least some of the uninitialized local variables to start with different values.

What is most bizarre, however, is that also changes depending on what system you run this code on:

// Output on ecelinux.uwaterloo.ca
4196861, 9.88131e-324, 0
Pi = 3.14
6295680, 2.07323e-317, 0

// Output on churchill.uwaterloo.ca (Windows)
1627411690, 2.122e-314, 0
Pi = 3.14
1817066142, 5.26696e+213, 97

// Output on repl.it
0, 6.9375e-310, 0
Pi = 3.14
32623, 6.9307e-310, 0

// Three executions on eceubuntu.uwaterloo.ca
32614, 0, 3
Pi = 3.14
32766, 6.92068e-310, 112

32685, 0, 77
Pi = 3.14
32765, 6.93581e-310, 145

32619, 0, 38
Pi = 3.14
32764, 6.92177e-310, 111

Thus, there is not even a guarantee that the values of uninitialized local variables will be the same on successive executions of the exact same program.

Scope of local variables

We have discussed how a local variable is temporary storage for data that is restricted to the scope of a function. It is used to store data that is only needed for the function to accomplish its task.

The scope, however, is actually more restricted than that: The scope of a local variable is restricted from the point at which it is defined up until the end of the block in which it is defined.

Recall that a block of code is a collection of statements surrounded by braces. Up to this point, the only blocks of statements we have seen is the function body and the bodies of conditional statements.

It is an error to try to access a local variable either:

1. before it is declared, or
2. after the end of the block in which it was declared.

The time during which the local variable can be accesses is described as that local variable's lifetime.

Parameters as local variables

It is reasonable to consider parameters to be local variables of the function body, only the initialization is done through the arguments that are passed when the function is called.

Using an identifier more than once

In general, it is a bad idea to have two local variables in the same function have the same identifier. There are rules under which this is possible, and if you wish to look at the details, please read this article on Oddities with local variables. This document should satisfy the mind of the enthusiast, but it is not required reading for this course. In general, do not ever have two local variables in a function have the same name. There is one case where it may be reasonable:

• when a local variable is required in two or more consequent or alternative bodies of a (possibly cascading) conditional statement, and
• where that local variable serves approximately the same purpose in each of the blocks.

One final comment on scope

A local variable can only ever be accessed in the block of statements in the function in which it is declared. Once the variable goes out of scope, it can no longer be accessed. A local variable defined in one function cannot be accessed directly in another function (we will see pointers and references later). Thus,

• If information stored in a local variable is required by the calling function, the value of that local variable should be returned.
• If the information stored in a local variable is required by a function that is being called, then that local variable should be passed as an argument to the function being called.

Assigning to local variables

To this point, we have discussed the initialization of local variables, but we may also want to modify the value stored in a local variable. When we modify the value stored in a local variable, we will call that assigning to that local variable. This is done with the assignment operator, which happens to look like an equal sign:

// Pre-process include directives
#include <iostream>

// Function declarations
int main();

// Function definitions
int main() {
    int n{42};

    std::cout << n << std::endl;  // This prints '42'

    n = 91;      // The value of '42' is lost forever

    std::cout << n << std::endl;  // This prints '91'

    return 0;
}

This will print the two values 42 and then 91. Both of these refer to the same memory location, so the value 91 overwrites the value 42 during the assignment.

In general, an assignment will look like:

        variable_name = expression;

where in general the expression can be anything that evaluates to something of the same type as the type that variable_name was declared. (This may require upcasting.)

	int n{42};
	int m{91};

	m = n + 1;

	int n{42};
	int m{91};

	if ( m == (n + 1) ) {
		// Some statements
	}

    int gcd{};     // The local variable to which we will assign
                   // the greatest common divisor of 'm' and 'n'

    if ( m == n ) {
        // the gcd is m
        gcd = m;
    } else {
        if ( m < n ) {
            // Swap 'm' and 'n'
        }

        assert( m > n );
        // Calculate the gcd
    }

        if ( m < n ) {
            // Swap 'm' and 'n'
            m = n;
            // The original value assigned to 'm' is gone
        }

        if ( m < n ) {
            // Swap 'm' and 'n'
	    int tmp{m};     // Assuming 'm' is of type 'int'
	    m = n;          // 'm' and 'n' now both store the original value of 'n'
        }

        if ( m < n ) {
            // Swap 'm' and 'n'
            int tmp{m};     // Assuming 'm' is of type 'int'
            m = n;          // 'm' and 'n' now both store the original value of 'n'
	    n = tmp;        // 'm' is now assigned the original value of 'n'
        }

        m + 1 = 5;

// Function declarations
int main();

// Function definitions
int main() {
        int n{10};
        10 = 17;
        10 = n;
        n + 1 = 20;

        return 0;
}

example.cpp: In function 'int main()':
example.cpp:7:5: error: lvalue required as left operand of assignment
  10 = 17;
     ^
example.cpp:8:5: error: lvalue required as left operand of assignment
  10 = n;
     ^
example.cpp:9:8: error: lvalue required as left operand of assignment
  n + 1 = 20;
        ^

// Pre-processor include directives
#include <iostream>

// Function declarations
int main();

// Function definitions
int main() {
    int m{0};

    std::cout << m << std::endl;
    std::cout << (m = 42) << std::endl;
    std::cout << m << std::endl;
    std::cout << (m = 91) << std::endl;
    std::cout << m << std::endl;

    return 0;
}

0
42
42
91
91

    // Never do this in your code...
    //  - this would be pure evil, but it compiles
    std::cout << ((m = 616) + 50) << std::endl;
    std::cout <<   m              << std::endl;

666
616

    // Suppose we want to set 'a', 'b' and 'c' all to 0
    a = 0;
    b = 0;
    c = 0;

    // Suppose we want to set 'a', 'b' and 'c' all to 0
    a = b = c = 0;

// Pre-processor include directives
#include <iostream>

// Function declarations
int main();

// Function definitions
int main() {
  int m{3};
  (m = 5) = 7;
  std::cout << m << std::endl;   // prints 7

  int a{1}, b{2}, c{3};

  a = (b = (c = 0));
  std::cout << a << ", " << b << ", " << c << std::endl;

  a = 1;
  b = 2;
  c = 3;

  ((a = b) = c) = 4;
  std::cout << a << ", " << b << ", " << c << std::endl;

  a = 1;
  b = 2;
  c = 3;

  a = b = c = 0;
  std::cout << a << ", " << b << ", " << c << std::endl;

  return 0;
}

#include <iostream>

int main();

int main() {
    double a{3}, b{4}, c{5};
    std::cout << ((a = 3*(b = 2*(c = a + 2*b*c - 1) + 7) + 2*b - 8*c + 131) - 100)
              << std::endl;
    std::cout << a << ", " << b << ", " << c << std::endl;

    return 0;
}

    double a{3}, b{4}, c{5};
    c = a + 2*b*c – 1;
    b = 2*c + 7;
    a = 3*b + 2*b - 8*c + 131;
    std::cout << (a - 100) << std::endl;
    std::cout << a << ", " << b << ", " << c << std::endl;

	a = a*(b + 3);
	a *= b + 3;

	b = b - 3 + a
	b += -3 + a

double max4a( double a, double b, double c, double d );
double max4b( double a, double b, double c, double d );

double max4a( double a, double b, double c, double d ) {
	// Assume 'a' is the largest
	//  - 'max_value' is declared a local variable of type 'double'
	//    and initialized with the value of 'a'
	double max_value{a};

	// If 'b', 'c' or 'd' are larger, update 'max_value'
	if ( max_value < b ) {
		max_value = b;
	}

	if ( max_value < c ) {
		max_value = c;
	}

	if ( max_value < d ) {
		max_value = d;
	}

	return max_value;
}

double max4b( double a, double b, double c, double d ) {
	if ( a >= b ) {
		if ( a >= c ) {
			if ( a >= d ) {
				return a;
			} else {
				return d;
			}
		} else {
			if ( c >= d ) {
				return c;
			} else {
				return d;
			}
		}
	} else {
		if ( b >= c ) {
			if ( c >= d ) {
				return c;
			} else {
				return d;
			}
		} else {
			if ( b >= d ) {
				return b;
			} else {
				return d;
			}
		}
	}
}

double max4a( double a, double b, double c, double d );

double max4a( double a, double b, double c, double d ) {
	double e{a};

	if ( e < b ) {
		e = b;
	}

	if ( e < c ) {
		e = c;
	}

	if ( e < d ) {
		e = d;
	}

	return e;
}

double triangle_area( double a, double b, double c );

double triangle_area( double a, double b, double c ) {
	// Enter your implementation here

	return 0.0;
}

double triangle_area( double a, double b, double c );

double triangle_area( double a, double b, double c ) {
	return std::sqrt( (a + b + c)/2.0*((a + b + c)/2.0 - a)
        	*((a + b + c)/2.0 - b)*((a + b + c)/2.0 - c) );
}

double F( int n );

	// Your code...
	return std::round( your_result );