Class Format

• Each week you'll have lesson material to go through at your own pace.
• In class, you'll work on homework and check in with the professors.
• During each class meeting, fill out a check in form to get credit for the day.
• You may attend class on Zoom if it's best if you don't attend in person (e.g., if you have symptoms of illness).

Homework

• Except for the first one, you'll have a partner for all homework assignments.
• Each partnership will have one 24-hour extension to apply to a homework deadline.
• We want you to support and learn from your classmates: be careful to preserve each other's learning processes.

Proficiency Checks

• Each week there are four proficiency checks, each focused on a single learning objective.
• Take proficiency checks in exam-like conditions.
• There will be opportunities to retry proficiency checks where you did not demonstrate proficiency the first time.
• During finals week there will be a final try at all remaining proficiency checks (with the possibility of partial credit).

Getting the Most Out of CS 70

• We are here to help! Please reach out to the course staff—and to each other—early and often!

CS 70 Memory Diagrams

• We use memory diagrams to help trace the correctness of C++ code.
• In our diagrams, we draw a variable's
  • value "inside the box" since it exists at runtime.
  • name, type, and location "outside the box" because they are useful for tracing the code, but they are not explicitly represented in memory at runtime.
• Our model abstracts away other details of specific computers (such as registers, the specific size of different numeric types, and the real naming conventions for memory slots) because those details vary from one computer to another, and are not helpful for modeling correctness.

C++ Guiding Principles

• Programming languages are designed by particular people, for particular purposes, in particular contexts.
• We discussed two principles that are important for explaining some of the design choices in C++ and let us reason about how the language behaves.
  • The Zero-Overhead Principle: Don't slow programs down “needlessly”.
    • Providing a lanuage feature should never slow down a program that doesn't use that feature.
    • Generally do things in the quickest possible way (even at the expense of safety or convenience).
  • The “Power to the People” Principle: Provide language features that allow expert programmers to do things in unsual ways.
    • Sometimes beginners accidentally use featues intended for experts!
• Both of these features mean we should not ignore compiler warnings when it notices we're doing something questionable!

Object Lifetime

• Every variable goes through the same 5 phases of object lifetime.
• The space for a local variable is allocated at the opening curly brace of the function where it's declared.
• The value of a variable is initialized on the line with its declaration.
• Once a variable's value is initialized, it is in use. For primitive values, that primarily means that its name is in scope, which means the name can be used in other expressions.
• The value of a variable is destroyed at the closing curly brace of the declaring block.
• Once a variable's value is destroyed, it is no longer in use. For primitive values, that primarily means that its name is out of scope, which means that the name cannot be used in other expressions.
• The space for a local variable is deallocated at the closing curly brace of the function where it's declared.

Numeric Types

• Numeric values in C++ can either be floating point (able to hold non-integer parts, like decimals) or integers (only able to hold integer values).
• Integer values in C++ can either be signed (able to hold positive and negative values) or unsigned (only able to hold non-negative values).
• Types like booleans and characters are numeric types in C++. A boolean, for example, is an integer type that is guaranteed to be able to hold two values.

Numeric Promotion and Conversion

• If a floating point is used where an integer type is needed, that is always conversion since the non-integer part of the value may be lost.
• If an integer type is used where a floating point is needed, that is always conversion since there may not be enough bits allocated to storing the integer part of the value.
• If a signed value is used where unsigned type is needed, that is always conversion since negative values cannot be correctly represented.
• If an unsigned value is used as a signed type of the same size is needed, that is always conversion since there may not be enough bits allocated to storing the magnitude of the value.
• If a value from a larger numeric type is used where a smaller numeric type is needed, that is always conversion since there may not be enough bits to store the value.
• If a value from a smaller numeric type is used as a larger numeric type of the same signedness is needed, that is always promotion since there will definitely be enough bits to store the value.

Compilation

• All of the C++ code we write will go through the following steps:
  • First, the compiler changes source code in to assembly code.
  • Next, the assembler changes the assembly code into object code.
  • Finally, the linker changes the object code into machine code.
• The compiler deals with all of the parts of variables that are not actually stored in memory at run time.
  • Specifically, that means that errors related to a variable's type or name will be caught at compile time!
• The (simplest) commands to compile a source file myprogram.cpp into an executable named myprogram and then run that program are
  • clang++ -c myprogram.cpp (compilation and assembly)
  • clang++ myprogram.o -o myprogram (linking)
  • ./myprogram (running the program)
• (In the homework we will typically have additional command-line options.)

Version Control

• A version control tool lets us keep track of all the different versions of our files, without having them clutter up our workspace.
• The version-control tool you will use this semester is called git.
• We also use a website called GitHub to have a shared, web-accessible place to put copies of everyone's repositories.

Pair Programming

• Pair programming is a skill. Like any skill, it requires practice and intention to get better.
• Our job this semester, collectively, is to support each other in developing that skill!

Arrays of Primitives

• Arrays are
  • Fixed-size — Once they're created, we can't change their size.
  • Homogenous — All of the elements in them have to be the same type.
  • Contiguous — If we looked at an array in memory, we'd see all of the elements side by side.
  • Ordered — We can talk about what the first, third, or forty-second element of the array is.
• Arrays allow constant-time access: We can jump straight to an arbitrary element of the array.
• In terms of object lifetime, arrays act just like individual variables. The compiler needs to know ahead of time how big the array will be, so that it can write the instructions to allocate enough space to store the array.
  • Declare and initialize an array: int arr[3]{1, 2, 3};
  • Usage: To access the item at index i: arr[i]
    • arr[i] is translated to *(arr + i)
    • *x means the value in memory at the address given by x
    • arr + i means the address at an offset of i from the address given by arr
    • So *(arr + i) means the value in memory at the address of the item at offset i from the start of the array.
  • Destruction and deallocation:
    • When the array is destroyed, each item is destroyed.
    • When the array is deallocated, all items are deallocated.
• Accessing an array out-of-bounds causes undefined behavior.
  • Undefined behavior means your program has gone off the rails, anything could happen, from something catastrophic to everything seeming to work.
  • You should never write a program that you know has undefined behavior just because nothing bad happened when you tested it.
• Typical C++ compilers generate code that does things the fastest and easiest way, without any special safety checks.
  • That includes finding the place in memory where we're claiming an item should be and interpreting the bits at that location as being of the appropriate type (that you asked for).
  • Accessing an array out-of-bounds can cause strange behavior. While, in principle, anything can happen when code causes undefined behavior, the strange behaviors you might see can vary between systems. But you can learn to recognize problematic behaviors, especially on the systems you use for coding and testing.
• Accessing memory that is way out-of-bounds can cause your program to crash.
  • The operating system will not allow your program to access memory outside of its allotted region.
  • This error is called a segmentation fault (segfault for short).

Code Style

• The goal of our code should always be to explain our thinking to other people who read the code.
• Similar things should look similar and different things should look different.

Testing

• When we write tests for our code, our goal should be to reveal bugs, not just demonstrate that our code "works".
• When you write tests, think about what edge cases you need to consider to make sure that your implementation is correct.
• If you make a mistake in your own code that results in "wrong" behavior, write a test for it! While we encourage test-first development, you can always add to your tests to make them more thorough as you develop a deeper understanding of where the tricky parts are in a particular coding task.

• We split our code into multiple files to avoid code duplication.
• A multifile program contains:
  • One or more source files (.cpp), exactly one of which has a main function.
  • One or more header files (.hpp), which declare functions that are defined in the source files (.cpp).

• Make sure that every header file (.hpp) has an include guard.

  #ifndef FILENAME_HPP_INCLUDED
  #define FILENAME_HPP_INCLUDED
  
  ...stuff...
  
  #endif
  

  • Include guards prevent multiple definitions when a header file is included more than once in the same source file.
  • Each preprocessor macro we use for an include guard must be unique (otherwise multiple files will be trying to use the same guard and only one of them will be seen), which is why we usually use the filename as part of the name.

• Make sure that each file uses #include to include any header files (.hpp) that declare things it uses.

  • That often includes a source file's own header file!
  • Sometimes header files need to include other header files!
  • Use #include "filename" for your local files from the current directory.
  • Use #include <filename> for system include files
• To compile your project:
  • Compile each source file (.cpp) into an object file (.o) using clang++ -c filename.cpp.
    • In practice, you'll probably want other flags too, such as -std=c++17, -g and -Wall -Wextra -pedantic.
    • (Remember from last week that this phase includes preprocessing, compiling the source file into assembly code, and then assembling the assembly code into machine code.)
  • Link object files (.o) together into an executable using clang++ -o executableName file1.o file2.o ...
• To recompile:
  • If a source file (.cpp) changes, recompile it into an object file (.o) and relink as necessary.
  • If a header file (.hpp) changes, recompile all source files that include it or that include a file that includes it, and so on.
• Rules of thumb:
  • Don't compile a header file (.hpp).
  • Don't #include a source file (.cpp).

• A variable with a reference type (e.g., int&) is just another name for an existing variable (in this case an int).
• An important use of references is as function parameters:
  • Allows the function to alter data outside of its stack frame.
  • Prevents unnecessary copy operations.
• The const keyword specifies that changes are prohibited (i.e., we have read-only access to the data).
  • The const keyword affects what we are allowed to do via a particular name, not what others might be able to do via a different name, so the same piece of data can have const names that cannot be used to change it and non-const names that can.
  • You cannot initialize a non-const reference (e.g., of type int&) with a const name (e.g., of type const int). That would circumvent the const restriction!
  • A const-reference function parameter is a good way to avoid needless copying but still promise not to change the given argument.

Recap Video

There was a fair amount to digest in this lesson. As a review, and because sometimes it's helpful to see things presented a different way, here's a video that goes over what we've covered in this lesson. If you feel like you've already mastered the material, you can skip it.

Key Points

• Classes are conceptually similar to what you've seen before, but have syntactic/terminological differences.
• Instead of “instance variables” and “methods” we say “member variables” or “data members” and “member functions” (“members” to refer to them all together).
• Declarations/definitions
  • The class definition goes in the header file (.hpp). It declares all of the class members.
    • In CS 70 convention we name all member variables with a trailing underscore (e.g., age_).
  • The member-function definitions go in the source file (.cpp). They specify the instructions for each function.
  • When we define a member function we have to specify which class it belongs to using the scope-resolution operator (::):
    • For example, void Cow::moo(int numMoos);.
• A member function can be declared const.
  • A const member function promises not to change the values of member variables.
  • If you have a const object, you can only call const member functions on it.
• We looked at two different kinds of constructors:
  1. Parameterized constructors take parameters and must be invoked explicitly (e.g., Cow bessie{3, 12}).
  2. Default constructors take no parameters and are implicitly invoked for default initialization (e.g., Sheep fluffy;).
• You can disable the use of a default constructor using the delete keyword (e.g., Cow() = delete;).
• In a constructor, the member-initialization list specifies how to initialize each member variable.
  • For example, Cow(int numSpots, int age) : numSpots_{numSpots}, age_{age}.
  • In CS 70, you must use a member-initialization list whenever possible. (The only exception is initializing a primitive array when you want a copy of another array—for that case, you need to loop over the elements of the array you're copying to populate your new array.)
• A class definition ends in a semicolon (;).
  • A class definition ends in a semicolon.
  • A class definition ends in a semicolon.

• Object lifetime on the stack: when?
  • Allocation: at the opening { of the function
  • Initialization: at the declaring line
  • Use: between initialization and destruction
  • Destruction: at the closing } of the declaring block
  • Deallocation: at the closing } of the function
• Default initialization/construction
  • int x;
  • Cow mabel;
  • Cow bessie{};
  • For an object, invokes the default (parameterless) constructor
• Copy initialization/construction
  • Creates a new object that is a copy of an exiting object
  • int x = y;
  • int a{b};
  • Cow mabel = adeline;
  • Cow bessie{fennel};
  • For an object, invokes the default constructor (which takes a reference to an object of the same type)
  • Also used to initialize function parameters and return values
• Assignment operator
  • Changes an existing object to be a duplicate of another existing object
  • s = t;
  • cadewyn = ethyl;
  • For an object, invokes the assignment operator, a special member function called operator=.
• Destructor
  • A special member function that is automatically invoked when an object is destroyed
  • For class Cow, the destructor is named ~Cow
  • Typically used to “clean up” or release any resources the object is holding onto
• The compiler can synthesize or disable these functions:
  • Cow(); // Means that the programmer will define the default constructor
  • Cow() = default; // Means that we will use the compiler's synthesized default constructor
  • Cow() = delete; // Means that this class does not have a default constructor
  • Same for default constructor, copy constructor, assignment operator, and destructor (but don't disable the destructor!!)
• For arrays, the same as above, only \( N \) times, where \( N \) is the size of the array.
• For references, initialization and destruction mark the usage period of the name
  • We don't model any allocation or deallocation for references
• For data members of a class
  • Allocation happens when the object is allocated
  • Initialization happens before the opening { of the constructor (so use the member-initialization list!)
  • Destruction happens at the closing } of the destructor
  • Deallocation happens when the object is deallocated