Copyright © 2016, 2022
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++

• See the CS 2040 page for the directions on installing the CS2040 VM
• Create a project:
  1. Start CodeLite and click on New Workspace with type C++
  2. Create the workspace in your Documents folder, say cs2040
  3. File|New Project
  4. hello
  5. Expand hello then src; see there is hello world
• 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 not supported (CLion, etc.)
• Create a hello world project
  • 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
    • 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
  • 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: 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
• 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

Review

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