Copyright © 2016
Robert W. Hasker

Note 5: C++ 101

Why C++?

What are some of the benefits of Java?
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?
- Benefits?
- Negatives?
- Is someone familiar with how programs do things like flash LEDs, display a pixel on the screen, move the read head on a disk drive?
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 Ruby, Python
- Ruby and Python: further hit due to lack of declared types
C++: objects plus speed
- Our target: C++14 and C++17

Starting point: Java == C++

NOTE: the following directions assume you have followed these directions for installing C++ and Eclipse
- There are lots of installation procedures that don't work - the published ones have been tested.
Create a hello world project in Eclipse
- Start Eclipse for C/C++ Developers (not Eclipse for Java developers)
- File | New | Project..., open C/C++, select C++ Project. Click Next
  - There is a C/C++ project in the New menu; that does not create the right sort of project for SE 2040.
- Enter a project name
- Clear the Use default location box
  - Putting projects in workspaces only works when you do all work within Eclipse; if you have other tools (such as git) you will want them "outside" the workspace
  - Browe to the project location; I usually create a new folder
  - It's also good practice to stay away from folders with spaces in the name (your Documents folder, etc.)
  - Assumption: you're either using something equivalent to DropBox or (better yet!) a git repository
- In Project type, select either Hello Word C++ Project.
- In Toolchains, select MingGW GCC
- Project | Build Project
- Click the green arrow (or Run | Run)
  - If a Run As window pops up, slelect Local C/C++ Application
- See here for directions about eliminating hard tabs
Hello, world!
- Why start there?
- #include, using - use library
- int main: no class, no static, no arguments (here)
  - The program is a value-returning function: OS can check result
- cout: "shout" to standard ("C") output
- <<: direction data is flowing
- endl: system-independent end line marker
- return: set result code; used by operating system
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: How to run 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:
Using Eclipse
- Other IDE's not supported (CLion, Visual Studio, etc.)
- Will practice debugging code in Eclipse

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?
- [What is 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 Eclipse, 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 DeMorgan'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
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

Variable sized array:

        int size;
        cin >> size;
        float scores[size]; // Ok! But fixed in size
        float *scores = new float[size];
        ...
        scores = new float[size * 2];

But how to access?
Just pretend it's a plain old array: scores[0], etc.

Pointers

In general: float *distance = new float;
- illustrate
- Assign 4.5 to distance:
```
        *distance = 4.5;
```
cout << int(distance); // print address as an integer
cout << *distance;
Pointers vs values:
- distance: the address
- *distance: dereferenced, the data (4.5)
- The difference may not seem significant, but the difference is just as strong as the difference between knowing the address of a house and actually walking in that house
Another useful operation: &
float some_data; distance = &some_data;
float scores[10]; // *scores is the first item - pointer to array
int *intp = nullptr;
- Used to use NULL or 0, but risky
see pointers.cpp
- accessing an array using pointer arithmetic
- dumping code from memory
- Assembly version of this code; generated by
```
        g++ -S pointers.cpp
```
  is in the file pointers.s
- Other things to note in pointers.s:
  - .Lnn: each line has a label; this is for the debugger
  - .ascii: constants that appear in the cod
  - Labels for function names start with _ in assembly code: this is standard in C-like languages so can mix assembly and compiled code
  - fib()'s name is _Z3fibi: the final i means this is the version that takes a single integer - if have other versions, those will have additional parameters
  - report(): _Z6reportPii: Pi = int*, i = int
  - Adding type information like this in compiled code is known as "mangling" - this allows projects to include both C and C++
heap vs. stack
Applications:
- int countOf(const int *nums, int target, int terminator) using for
- char *text = "MyName"; -- what is the length?

Basic Structure of C++ Programs

Next: classes
But don't have to use classes to get work done!
- Basic model of program: input data, process it, output results - input/process/output
Implication for design:
- Program = sum of functions
- All functions: either input, process, or output
- Mixing two of these makes it difficult to reuse code
Focus on reading from standard input/writing to standard output: reuse of entire programs!
- Simple spell check:
```
        cat document.txt | tr '[A-Z]' '[a-z]' | tr -s '[^a-z]' '\n' | sort | uniq | cat - dictionary.txt dictionary.txt | sort | uniq -u
  
```
- This translates upper case to lower, non-alphabet to newlines (so one word per line), creates sorted list of unique document words, then sorts again against a dictionary and prints all unique words in the result
- All done with no extra files

Review

motivation for C++, compilation
Basic input, output
fundamental types, operations
main, a bit about functions
pointers, arrays
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 Robert W. Hasker

Note 5: C++ 101

Why C++?

Starting point: Java == C++

Ch. 1: How to run a C++ Program

Programs from the bottom up

Operations on data

Scope & Lifetime

Constants

Arrays

Pointers

Basic Structure of C++ Programs

Review

Copyright © 2016
Robert W. Hasker