Copyright © 2016, 2023
Robert W. Hasker

Note 2: C++ 101

A more detailed discussion of "why C++?"

• Note 1: Java's "run anywhere" has consequences
  • Overhead from automated garbage collection, run-time checks
  • Limited control of hardware since not all machines have the same capabilities at the hardware level
  • For example, some machines provide checks on processor health, ways to temporarily speed up processing, different ways to do input and output
  • BTW, the same discussion applies to Python
    • Python: even slower due to limited type information to analyze
• JVM is key to "run anywhere", but how is it implemented?
  • This must be platform-specific; it cannot be written in pure Java
  • All of the well known Java Byte Code Interpreters use C++ or C with a bit of assembly
• A more precise view of Java:
  • Cannot be just "runs on any machine" - C/C++ gives you that!
  • Compile once and runs on any machine with the same result
• How to characterize C++?
  • C: provides machine connection, low overhead/speed, but no OO
  • 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: Getting programs to run

• 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
  • NOTE: a lot of this is similar to Java! Focus on just the differences below...
  • #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
  • How different from a method?
    • A method is a function that is a member of a class
  • prototype: function header followed by semicolon
• 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);
• Basic theme: C++ shares a lot with Java!
  • Our focus: what's different

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
• and: &&
  • Recall from Java: if a is false in a && b, then b is not even evaluated! - why?
  • Known as short-circuiting and
• or: || - also short-circuiting - when?
• short-circuiting is very important in both C++ & Java to ensure we do not process bad data:

          if ( index < LIMIT && items[index] == target ) ...
  

• 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
    • See TestReflection.java
    • certainly rarely used in production code outside of libraries, 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 p1, type p2, ...) {
          ... 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 p1 and p2 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;
            nums[x] = 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