Copyright © 2016, 2023
Robert W. Hasker

Note 2: C++ 101

Why C++?

What are some of the benefits of Java?
What is automated garbage collection, and how is it useful?
Describe how garbage collection works, when it applies in Java
- What is the impact of automated garbage collection?
What does "run anywhere" mean in Java?
- Not just "runs on any machine" - C comes close to giving you that - but "compile once, runs on any machine with same result"
- Benefits?
- Negatives?
- Is someone familiar with how programs do things like flash LEDs, display a pixel on the screen, open a latch?
When you create an object with new in Java, what happens?
- Why might we need to reclaim this memory at some point?
- How does automated garbage collection play a role in this?
- When does the garbage collector "run"?
- Why would automated garbage collection be part of "run anywhere with the same result"?
Consider flight control software
- Must check sensors, compute new flap positions, several times a second
- For some systems, "several" = tens of thousands
- Need low-level access
- Automated garbage collection can mean missing deadlines
- Note: garbage collection can be bounded, but for a trusted system (or a computer game!) you would need to show that bound can happen at any moment without impacting the system
Conclusion: garbage collection, "run anywhere" is both a reason to use Java and a reason to not use Java!
- BTW, the same arguments apply to Python
- Python: further hit due to lack of declared types
C++: objects plus speed
C++ has had many versions; we are targetting C++17 or later
- This is significant because C++11 has many important new features - some describe it as a "new" language

Starting point: Java == C++

See the CSC 2210 page for the directions on installing the development environment
Create a project:
1. Start CLion, New> Project
2. Set location, project name
3. Browse to main.cpp, review that code
  - Why do we start with hello, world!?
4. Run it.
NOTE: the following directions assume you have followed the directions on the course website for for installing a C++ development environment
- There are lots of installation procedures that don't work - the published ones have been tested.
- Other IDE's are not supported (Eclipse, etc.)
Pieces of the hello world project
- #include, using - use library
- int main: no class, no static, no arguments (here)
  - The program is a value-returning function: OS can check result
  - On Dos: echo %ErrorLevel%
  - On Linux (with Bash): echo $?
- cout: "shout" to standard ("C") output
- <<: direction data is flowing
- endl: system-independent end line marker
  - When using endl (that is, your output is a series of lines), be sure the last output line is terminated with an endl
  - That is, make sure the last output statement is of the form
```
        cout << something-or-other << endl;
```
- return: set result code; used by operating system
Refine to prompt for name and write hello, <name>
- #include <string>
- Declare string name;
- print name
- add if name == "Walz" print "lord" instead
  - Note can simply compare strings - no need to use .equals
Maximum of two numbers
- cin: read data from (standard) input
- Big win: simple read/write of data - no buffered writer evaluator stuff
- Rewrite with min function
- Still no classes!
- What is a function?
  - A named sequence of statements performing an action
    - Naming gives us power over something, correct?
  - avoid repetition - write once!
  - decompose big problem into smaller ones - basic problem solving 101
Average a list of numbers with prompt for number of numbers
Eof-controlled loop to average numbers: ave.cpp
How to round a number?
- There is no round() function in standard libraries
- double x; cin >> x;
- int rounded = int(x + 0.5);

Ch. 1: Running a C++ Program

What are the steps for running a Java program?
Challenge for C++: there is no virtual machine: must have machine code
Translating a program into machine code:
Show how to compile, run in IDE

Programs from the bottom up

Starting point: types
- Without types, no data; without data, rather uninteresting programs!
Basic C++ types:
- int: integers - no Integer class
  - Big difference from Java: there are values that are not objects
  - int: close match to signed integer in machine
  - fits in one word
- char: character: 'A', 'x'
- bool: boolean; values true and false
- float: floating point numbers: 3.14159
- double: double-precision floating-point numbers
  - Usual precision for float: 6 digits; double: 12 to 18
- unsigned int, or just unsigned: non-negative integers
  - Usual limit for int: 2 billion; unsigned: 4 billion
- short: short integers - often 16 bits (-32768..32767)
  - What is a bit?
  - How many bits in a byte?
- long: long integers: could be 64 bits, but often 32
  - Interest in efficiency means that types like int, long match the underlying hardware
  - There is a library of standard types when you know the limits (such as uint32_t for unsigned 32-bit integers)
  - Most data is small so it's often not worth worrying about.
    - And if the size is important, why haven't you tested for it??
- long long: often 64-bit integers - probably should use int64_t instead!

Operations on data

See textbook: have +, %, etc just like Java
- All of the Java operators you know work in C++
- They do have differences in how they work, but we'll cover those later
sizeof(): used to find the size of a type
- Returns number of bytes: eg, sizeof(short) is typically 2
- On some platforms (eg Microsoft C++), sizeof(bool) is not well-defined
- Guarantee:
```
    By definition: sizeof char == 1
    1 == sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long)
```
- Number of bits in a char is not defined; it is often 8, but on some systems it is 64!
- sizeof(float) <= sizeof(double), but no general rule for floating-point vs. integers

Declaring: initialize simultaneously:

        int count = 0;
        int count {0};   // alternative form
        int count = 0.5; // count = 0, but no error
        int count {0.5}; // ILLEGAL - get error, but this is good!

Can also use auto when the type is specified:

        auto b = true;  // bool
        auto ch = 'x';  // char
        auto count = 0; // int
        auto d = 1.2;   // double

Don't need {0.5} initializer form since can't get a type error with auto

++x vs x++
- x = 5, y = ++x; sets y to?
- x = 5; y = x++; sets y to?
- ++x slightly faster in most cases, and substantially faster in a few cases
Full operator table: CPPReference.com
- A key source of C++ detail

Scope & Lifetime

Programming language concept
Identify scope, lifetime for sample code
C++: allows global scope, lifetime
- Java: support for global lifetime, scope?
Objects must be constructed/initialized before being used
- But no checks!
- int x; cout << x; is perfectly legal
Objects are generally destroyed at the end of their scope
- static changes these rules

Constants

const int x = 5; - x will not change in this scope
constexpr y = 5 - evaluated at compile time
- The notion of "run time" vs. "compile time" is critical in C++
- In Java, almost anything can be changed at run time
  - adding methods, attributes, changing class hierarcies
  - probably best avoided, but...
- C++: no way to introduce new elements to a class at run time

constexpr vs const:

        const int a = get_integer();     // legal (assuming get_integer reads num)
        constexpr int a = get_integer(); // NOT legal

Would generally use upper case for constexpr:

        constexpr int MAX_LENGTH = 100;
        constexpr int SECONDS_PER_DAY = 60 * 60 * 24;

How do you specify large floating point values?
- [How many zeros in 100000000000000000000000000000000000000000000000000.0 ?]
- [What is a better way to write that?]

Arrays

Read 10 lab scores (floats) - make the 10 a constant
Exercise: check lab scores always increasing
- Using the IDE, write code to read lab scores (as floats) until eof
  - Print "increasing" or "not increasing" as appropriate
  - Remember pattern for eof-controlled loop in C++ (following ave.cpp):
```
        read
        while not eof
           process
           read
```
  - Plan for writing loops:
    1. Write terminating condition - repeat until x
    2. Write while loop header: while !x
      - Use De Morgan's laws: !(a && b) == !a || !b
        !(a || b) == !a && !b
    3. Write loop body; make minimal progress each time through
      Goal: while test will eventually become false
    4. Do any setup before the loop, such as initialize variables
    5. Do any cleanup after the loop such as closing files
  - Apply to reading data: stop at eof (!cin) or array is full
  - Apply to finding first entry where x_i ≤ x_i+1 (or run out of items to examin)
  - Solution: increasing-numbers.cpp
    - Run this example in CLion including reading from a sample input file using run configurations
Introduce function alwaysIncreasing
- Specify size of array as a parameter - no .length in C++
- use int for counter
- better: auto - allows cases where index not an int
- Can generate this by highlighting search code and selecting Refactor | Extract into function
Changes:
- would generally use a vector class - will discuss later
  - need "raw" array if using memory-mapped hardware control
- alternative definition: float * (just note it works for now)
- do: mark array parameter as const
Initializing arrays with {}
- int fibs[] = {1, 1, 2, 3, 5, 8, 13};
- Printing contents:
```
        for(auto x : fibs) cout << x << endl;
```
- What happens if specify size too small, too large
- Simple initialization of array to 0: int nums[100] = {0};
- Uninitialized array
- sizeof(fibs): 7 * sizeof(int)
  - This only works within the function where fibs is declared - it won't work in parameters

General notes on Functions in C++

General form of a C++ function:

    return_type name(type p₁, type p₂, ...) {
        ... body ...
      }

Terminology:
- method: an operation in a class; the only way to do things in Java
- function: any named piece of code; Like most languages, C++ allows functions that are not a member of any class
- procedure: a function that doesn't return a result; we often use "function" generically and "procedure" for a void function
- mathematical function: the types of functions you learned about in math courses such as sine or f(x) = x² - 3.
  - These differ from programming functions because mathematical functions always give the same result for a particular argument; eg, f(4) isn't 13 one time and 12 another.
  - Programming functions can have different results, often because they read information from a file or the user.
- argument: a value passed to a function like x in sqrt(x)
- parameter: the name given to the value passed in to the function; eg, the p₁ and p₂ above
Return type
- Can be any type, both simple types like int or double and classes like string
- void: indicates no return statement
  - Given void p(int x);, the code y = p(3); would be illegal since you can't create or store a void value
- If a (non-void) function has no return statement, the return result is undefined - that is, it could be anything
- In C/C++, you can always ignore a return result. For example,
```
        float f(float x) { return x * x + 3 * x - 5; }

        ...
        f(5);  // legal, even if not useful!
```
  This is because there are several library functions that return results that can be routinely ignored such as functions which read input and return the number of items read.

Overloading

Like many languages, C++ allows overloading on function types:

        int distance(int a, int b) { return a > b ? a - b : b - a; }
        double distance(double a, double b) { return a > b ? a - b : b - a; }
        double distance(double x1, double y1, double x2, double y2) {
          double x_delta = x2 - x1, y_delta = y2 - y1;
          return sqrt(x_delta * x_delta + y_delta * y_delta);
        }

cannot overload on return type:

        int f(int a);
        double f(int a);        // illegal!

Can also overload operators:

        string operator+(string a, string b) {  // REALLY bad idea!!
          string result = "xx";
          result[0] = a[0];
          result[1] = b[1];
          return result;
        }

This is why you don't need .equals; the libraries overload operator= for two strings
Constraint: you cannot redefine operations on built-in types
```
        int operator+(int a, int b); // ILLEGAL!
```

Another nice feature in C++: optional arguments:
```
        double f(int x, double y = 0.0, double z = 0.0) {
          return x + 2 * y + 3 * z;
        }
```
Then the following are all legal calls: f(3), f(4, 5), f(5, 5, 6); for f(4, 5), z is 0 - drop right to left

Regular parameters are passed by value, arrays by reference; given

        void doit(int x, double nums[]) {
          x *= 2;
          x[nums] = x * x;
        }

        double stuff[100];
        int a = 5;
        doit(a, stuff);

then a will still be 5 after the call, but stuff[10] will be 25.

Review

motivation for C++, compilation
Basic input, output
fundamental types, operations
main
arrays
functions
see textbook for switch statement - key differences are that strings are not allowed and that can fall through from one case to another

Copyright © 2016, 2023 Robert W. Hasker