Week 4

Let’s review functions. Remember that functions are like black boxes that take 0 or more inputs (aka arguments or parameters) and return 0 or 1 output. Functions might also have a side effect (e.g. print something to the console).

Local variables (defined inside functions) are known within functions wherein they were defined.

Local variables are passed by value to other functions.

In this example, doubleScore has no effect on playerScore declared in main:

int doubleScore(int score);

int main() {
    int playerScore = 100;
    doubleScore(playerScore);
}

int doubleScore(int score) {
    score = score * 2;
    return score;
}

And here, the value of playerScore is overwritten by the return value of doubleScore:

int doubleScore(int score);

int main() {
    int playerScore = 100;
    playerScore = doubleScore(playerScore); (1)
}

int doubleScore(int score) {
    score = score * 2;
    return score;
}

Here’s another example. Try to figure out what this program prints:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <iostream>
using namespace std;

// prototypes
void foo();
void bar();

// global variable
int x = 5;

int main() {
    cout << x << endl;
    int x = 7;
    cout << x << endl;
    foo();
    cout << x << endl;
    bar();
}

void foo() {
    x = 10;
    int x = 42;
    cout << x << endl;
}

void bar() {
    cout << x << endl;
}

We often want to swap two variables' values in programs. Suppose we have two integers, a, that has a value of 2, and b, that has a value of 5. After swapping a and b, we want a to have a value of 5 and b to have a value of 2.

To illustrate how to swap to variables, recall that we can think of variables as containers that can hold something. Then suppose we have two cups: one has some orange juice and the other one has milk. If we want to swap the contents of the two cups, we must use a third cup (let’s call it temp).^[1] We can pour orange juice into the temp cup, then we can pour milk into the cup that used to hold orange juice, and finally, we’ll pour orange juice from the temp cup into the cup that used to hold milk.

Similarly, to swap two variables' values, we need a third, temporary variable. Here’s an example:

int temp = a;
a = b;
b = temp;

a = a + b; (1)
b = a - b; (2)
a = a - b; (3)

Now, let’s write a program that swaps two variables' values using a function:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <iostream>
using namespace std;

/**
 * Requires: Nothing.
 * Modifies: Nothing.
 * Effects:  Fails to swap arguments' values.
 */
void swap(int a, int b);

int main() {
    int x = 2;
    int y = 5;

    cout << "x is " << x << endl;
    cout << "y is " << y << endl;
    cout << "Swapping..." << endl;

    swap(x, y);

    cout << "Swapped!" << endl;
    cout << "x is " << x << endl;
    cout << "y is " << y << endl;

    return 0;
}

void swap(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
}

x is 2
y is 5
Swapping...
Swapped!
x is 2
y is 5

Comparison operators are binary operators, which means that they are used to compare two values.

Notice how two equal signs (==) are used for comparison. By contrast, a single equal sign (=) is used for assignment.

The result of comparing two values is always a bool, i.e. either true or false.

To execute some code only if some condition is true, write something like this:

if (condition) {
    // do this
}

If you want to execute some code if a condition is true, and some other code if that condition is false, write something like this:

if (condition) {
    // do this
} else {
    // do that
}

Here’s an example that prints different things depending on whether the value of course is 183:

if (course == 183) {
    cout << "EECS 183 is Elementary Programming Concepts"
         << endl;
} else {
    cout << "I'm not familiar with that class!" << endl;
}

And here’s another familiar example from Project 1:

string pluralize(string singular, string plural,
                 int number) {
    if (number == 1) {
        return singular;
    }
    return plural;
}

And if you want to have three (or more) forks in the road, you can do this:

if (condition) {
    // do this
} else if (condition) {
    // do that
} else {
    // do this other thing
}

Let’s expand on the previous example:

if (course == 183) {
    cout << "EECS 183 is Elementary Programming Concepts"
         << endl;
} else if (course == 203) {
    cout << "EECS 203 is Discrete Mathematics" << endl;
} else {
    cout << "I'm not familiar with that class!" << endl;
}

And another example that prints different things depending on how x compares to y:

if (x < y) {
    cout << "x is less than y" << endl;
} else if (x > y) {
    cout << "x is greater than y" << endl;
} else {
    cout << "x is equal to y" << endl;
}

For each statement below, determine if it is true or false.

Boolean expressions can be used as conditions in if/else statements to make them more interesting. They always evaluate to true or false.

There are three logical operators that you can use to build boolean expressions. The first two are binary operators (they operate on two operands) and the last one is a unary operator.

To illustrate how these logical operators work, we can use truth tables.

We can use these logical operators to build more interesting conditions in if/else statements:

if (condition && condition) { (1)
    // do this
}

if (condition || condition) { (2)
    // do this
}

if (!condition) { (3)
    // do this
}

If you ever find yourself wanting to write this code, where you don’t do anything if some condition is true, but to something if that condition is false, as in

if (condition) {
    // do nothing
} else {
    // do something
}

if (!condition) {
    // do something
}

As in math, some operations evaluate before others, and there is a specific, defined order.

From greatest to smallest priority, C++ operators are evaluated in the following order. This table does not include all of the operators in C++, but it does cover all of the ones you’ll see in EECS 183.

For a complete table of precedence and associativity of all C++ operators, take a look at http://en.cppreference.com/w/cpp/language/operator_precedence.