4. Computation

We often have the idea of some constant value we want to name, but we don't want ever to be changed; for instance, pi can't change in the course of a program, so we can write:
constexpr double pi = 3.14159;
After that, we can just use pi whenever we need that value. And if we at some point need more precision, we can just add it to the constexpr and not need to roam around our program changing it in many spots.

C++ also has the idea of a const the value of which is not known at compile time, but can't be changed after it is set. So:
const c2 = n + 7;
The value of n won't be known until the code is run, but once c2 is set to n + 7, it can't be changed later on.

Operators serve to combine literal or variable values to create a new value. Here are the most common operators:

We can "mix" different types in expressions: what is the type of the result? There are rules for this. For instance:

• 5/2 is 2
• 2.5/2 means 2.5/double(2) == 1.25
• 'a'+1 means int{'a'}+1

type(value) and type{value} mean "convert value to type. The difference between them is that the version with squiggly braces {} prevents narrowing, but the one with parentheses () does not.

Be careful not to write something like:

double dc;
cin >> dc;
double df = 9/5*dc+32;
                            

9/5 is equal to 1, not 1.8! Write 9.0/5.0 to get the result you want.

The simplest form of selection is an if statement, which selects between two alternatives; for instance, here is code that returns the maximum of two values:

int max(int a, int b)
{
    if(a<b)
        return b;
    else
        return a;
}
                            

The notion is simple: if a condition is true, do one thing, else if it is false, do another. If the class you want is available, register for it, else, choose a different class:
if(my_choice==available) choose_it();
else choose_another();

When we have many alternatives to choose among, it may be clearer to express them in a switch statement, like this:

switch (grade) {
case 'A':
    cout << "You done great!"
    break;
case 'B':
    cout << "That's pretty good."
    break;
case 'C':
    cout << "Not bad, but we hope for better."
    break;
case 'D':
    cout << "Consider retaking the course."
    break;
case 'F':
    cout << "You're going to have to retake the course."
    break;
}
                            

When many cases should result in the same behavior, then omitting the break statement can merge those cases:

                                switch (num) {
                                case '0': case '2': case '4': case '6': case '8':
                                    cout << "Digit entered was even.";
                                    break;
                                case '1': case '3': case '5': case '7': case '9':
                                    cout << "Digit entered was odd.";
                                    break;
                                default:
                                    cout << "That wasn't a digit".
                                }
                            

Switch technicalities:

1. The value switched on must be a character, integer, or enumeration type. You can't switch on strings or other more complex objects.
2. The values in the case labels must be constants.
3. No two case labels can have the same value.
4. You can use several case labels for a single case.
5. Typical source of bugs: forgetting to use a break when you don't want to drop through to the next case. The compiler will think you meant to do 4. above.

Write a program that accepts some input from a range, like letter grades, and then uses a switch statement to reply with a message based on the input.

Iteration executes the same (block) of statements repeatedly. (Hopefully, this stops at some point!) The two C++ looping constructs are:

int main()
{
    int i=0;
    while(i<100) {
         cout << i << '\t' << square(i) << '\n';
         i++;
    }
}
                            

int main()
{
    for(int i=0; i<100; ++i)
        cout << i << '\t' << square(i) << '\n';
}
                            

• Makes the computation logically separate
• Make the program logically clearer (by naming the computation)
• Makes it possible to use the function in more than one place
• Eases testing (we can test functional units separately)

Why use square() instead of a function named print_square() that both squares a number and then prints it?
Basically, we want a function to do one thing, not two, as then we can use it in more places: e.g, where we just want to square a number but then use the result in another computation without printing it.

We must differentiate between function declarations and function definitions. The declaration of a function need only announce the type it returns, its name, and the types of its arguments. The function definition must include how it carries out its work. Often in our programs, we just want to mention the declaration part of a function, so the compiler knows if we are using it wrongly, and not include the definition, which may live in some third-party library. We typically do that in header files, with the extension ".h".
A function declaration looks like:
int square(int);

We can traverse a vector as follows:

vector<int> v = {5, 7, 9, 4, 6, 8};
for(int i = 0; i<v.size(); i++)
    cout << v[i] << '\n';  
                            

To traverse a vector we need to traverse the half-open sequence v[0] to v[v.size()-1].

C++ has a built-in way to loop over everything in a half-open sequence:

vector<int> v = {5, 7, 9, 4, 6, 8};
for(int x : v)
    cout << x << '\n';  
                            

This is called a range-for-loop, since range is a synonym for "a sequence of elements."
More complicated loops involving vectors are tyoically better coded in the traditional for-loop style listed above.

We grow a vector by using its push_back() method. For instance, this code:

vector<double> v; // empty vector! 
v.push_back(2.7);
v.push_back(5.6);
v.push_back(7.9);

                            

Results in:

push_back() is a member function of the class vector.

Write a program that uses a while loop to accept a series of integers from the user, adds them as new elements to a vector, and then, once the user ends input, prints out the vector with a for loop.

To illustrate a somewhat realistic example of growing a vector, we're going to read in a series of values and calculate their mean.

#include "std_lib_facilities.h"

int main()
{
    cout << "Enter recent temperatures and we will calculate their average:\n";

    vector<double> temps;
    for(double temp; cin>>temp; )
        temps.push_back(temp);
    double total = 0.0;
    for(double temp : temps)
        total += temp;
    double mean = total / temps.size();
    cout<<"Your mean temperature for the last "<<temps.size()<<" days was "<<mean<<'\n';
    keep_window_open();
    return 0;
}
                            

Modify the above program, using the sort() facility to also get the median temperature.

Write a program that accepts a series of words as input and writes out a concordance, a list of all the words in the text, in alphabetical order, along with how many times each word occurred.
Hint: Use the sort function provided in std_lib_facilities.h to do this.

Modify the mean temperature program to produce a concordance of words, listing each word in a text in alphabetical order, along with the number of times it occurred in the text. (Hint: You will find sort() useful here as well.)

1. c; 2. a; 3. b; 4. b; 5. b; 6. b; 7. c;