cs19f25

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
<WRAP round info>
====== Week 00 Materials ======

This week is for participants in the experimental CS 19 Boot Camp.
</WRAP>

===== Monday =====

{{ :lecture_materials:cabrillo_-_c_boot_camp_-_monday_session.pdf |Pascal Broca: Introduction and Overview}}

{{ :lecture_materials:monday_camp_development_cycle.pdf |Daria Malysheva: Software Development Cycle}} 

===== Tuesday =====

==== Scope and Lifetime ====

{{ :lecture_materials:blocks-scope-lifetime.pdf |Jeffrey Bergamini: Blocks, Scope and Lifetime}}

=== scopes.cpp (illustrating locally and globally scoped variables) ===

<file cpp scopes.cpp [enable_line_numbers=true]>
/**
 * @file scopes.cpp
 * @author Jeffrey Bergamini for CS 19 Boot Camp, jeffrey.bergamini@cabrillo.edu
 *
 * Let's see how much you understand/remember about scope and lifetime in C++!
 */

#include <iostream>

int x;

void f1() {
  x = 2;
  std::cout << x << '\n';
}

void f2(int x) {
  std::cout << x << '\n';
  {
    int x;
    x = 4;
    std::cout << x << '\n';
  }
  x = 5;
  std::cout << x << '\n';
}

int main() {
  x = 1;
  std::cout << x << '\n';
  f1();
  std::cout << x << '\n';
  f2(3);
  std::cout << x << '\n';
  int x;
  x = 6;
  std::cout << x << '\n';
}
</file>

<WRAP round info>
== Notes ==

Your job: Be the compiler and the shell and determine the output of this program without using any tools other than your mind!

Then compile and run this code to see if you were right.
</WRAP>

=== scopes_annotated.cpp (illustrating locally and globally scoped variables) ===

<file cpp scopes_annotated.cpp [enable_line_numbers=true]>
/**
 * @file scopes_annotated.cpp
 * @author Jeffrey Bergamini for CS 19 Boot Camp, jeffrey.bergamini@cabrillo.edu
 *
 * Let's add *memory addresses* to the output to see which symbol `x` represents in which context.
 */

#include <iostream>

int x;  // global variable, global scope

void f1() {
  x = 2;  // assigns to global variable `x`
  std::cout << &x << '\t' << x << '\n';
}

void f2(int x) {
  std::cout << &x << '\t' << x << '\n';
  {
    int x;  // local variable (local to function `f1()`), scoped within anonymous block
    x = 4;  // assigns to local variable `x` scoped within anonymous block
    std::cout << &x << '\t' << x << '\n';
  }
  x = 5;  // assigns to local variable `x` (function parameter)
  std::cout << &x << '\t' << x << '\n';
}

int main() {
  x = 1;  // assigns to global variable (i.e., global var `x` is a *lvalue*)
  std::cout << &x << '\t' << x << '\n';
  f1();
  std::cout << &x << '\t' << x << '\n';  // function `f1()` should have mutated global variable `x`
  f2(3);
  std::cout << &x << '\t' << x << '\n';  // function `f2()` has not mutated global variable `x`
  int x;                                 // local variable, local scope
  x = 6;  // assigns to local variable `x` (global `x` is now "shadowed" for the rest of the block)
  std::cout << &x << '\t' << x << '\n';
}
</file>

<WRAP round info>
== Notes ==

This is the same program, but prints the **memory address** of each variable in question. Note which ''x'' variables are at the same address, i.e. are literally the same integer object.
</WRAP>

=== raii.cpp (illustrating the concept of RAII) ===

<file cpp raii.cpp [enable_line_numbers=true]>
/**
 * @file raii.cpp
 * @author Jeffrey Bergamini for CS 19 Boot Camp, jeffrey.bergamini@cabrillo.edu
 *
 * RAII: "Resource acquisition is initialization"
 * Perhaps easier to understand: "scope-based resource management"
 *
 * An object's resources (memory storage, file handles, etc.) are allocated during initialization,
 * and released during destruction. When an object's lifetime ends, its resources should be
 * deallocated/cleaned up/closed/etc.
 *
 * We'll run this through `strace` to verify when files are opened/closed:
 * strace --trace=openat,close ./a.out </srv/datasets/shakespeare-othello.txt
 */

#include <cctype>
#include <fstream>
#include <iostream>

// Counts and returns the number of English vowel characters in an input stream.
size_t count_vowels(std::istream &source) {
  size_t vowel_count = 0;
  for (char c; source >> c;) {
    c = std::tolower(c);
    if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u')
      ++vowel_count;
  }
  return vowel_count;
}

int main() {
  std::ifstream hamlet{"/srv/datasets/shakespeare-hamlet.txt"};
  // Preview of subtype polymorphism: A `std::ifstream` *is a* `std::istream`
  // (i.e., an input stream reading from a file is a specific kind of input stream)
  std::cout << "Hamlet: " << count_vowels(hamlet) << '\n';
  std::cout << "Hamlet again: " << count_vowels(hamlet) << '\n';
  {
    std::ifstream macbeth{"/srv/datasets/shakespeare-macbeth.txt"};
    std::cout << "Macbeth: " << count_vowels(macbeth) << '\n';
    // Lifetime of `macbeth` ends here. File will be closed.
  }
  std::ifstream othello{"/srv/datasets/shakespeare-othello.txt"};
  std::cout << "Othello: " << count_vowels(othello) << '\n';
  // std::cin is just a plain input stream:
  std::cout << "std::cin: " << count_vowels(std::cin) << '\n';
  // Lifetimes of `hamlet` and `othello` end here.
  // Will be closed in the opposite order of initialization (`othello`, then `hamlet`)
}
</file>

<WRAP round info>
== Notes ==

[[https://en.wikipedia.org/wiki/Resource_acquisition_is_initialization|RAII]] is a horrible acronym, but understanding its consequences in C++ is important.
</WRAP>

=== scope_lifetime_practice.cpp (an opportunity to think and practice) ===

<file cpp scope_lifetime_practice.cpp [enable_line_numbers=true]>
/**
 * @file scope_lifetime_practice.cpp
 * @author Jeffrey Bergamini for CS 19 Boot Camp, jeffrey.bergamini@cabrillo.edu
 *
 * Some lunchtime practice!
 */

#include <cctype>    // for `std::isprint()`
#include <fstream>   // for `std::ifstream`
#include <iostream>  // for `std::cout`

/**
 * `main()` can have parameters to access *command-line arguments* and *environment variables*.
 *
 * @param argc argument count: the number of command-line arguments (including the executable name)
 * @param argv argument values: an array of C strings containing the command-line arguments
 */
int main(int argc, char **argv) {
  // Exit with an error message if command-line arguments weren't provided:
  if (argc < 3) {
    std::cerr << "Usage: " << argv[0] << " FILE1 FILE2\n";
    return 1;  // nonzero exit status reports unsuccessful termination to the shell
  }
  // Attempt to open the two files specified as command-line arguments:
  std::ifstream f1(argv[1]);
  std::ifstream f2(argv[2]);
  if (!f1 || !f2) {
    std::cerr << "Cannot read from input file(s)\n";
    return 2;
  }
  // TODO: Find all the unique printable characters present in one file and not the other.
  // Print each unique character and its ASCII encoding, one character per line, in ascending order.
}
</file>

<WRAP round info>
== Notes ==

Having some data to test with is useful. I have many textual datasets available. If you have your program in a form that is executable in a terminal, the following commands should work for testing:

Command:
<code bash>
./a.out <(echo suitably) <(echo implausible)
</code>

Expected Output:
<code>
e	101
m	109
p	112
t	116
y	121
</code>

Command:
<code bash>
./a.out <(curl -s https://jeff.cis.cabrillo.edu/datasets/genius.txt) <(curl -s https://jeff.cis.cabrillo.edu/datasets/injust.txt)
</code>

Expected output:
<code>
'       39
,       44
-       45
.       46
J       74
M       77
j       106
k       107
v       118
</code>

Command:
<code bash>
./a.out <(curl -s https://jeff.cis.cabrillo.edu/datasets/shakespeare-hamlet.txt) <(curl -s https://jeff.cis.cabrillo.edu/datasets/shakespeare-macbeth.txt)
</code>

Expected Output:
<code>
"       34
#       35
$       36
%       37
*       42
+       43
/       47
0       48
4       52
5       53
6       54
7       55
8       56
9       57
<       60
=       61
>       62
@       64
J       74
U       85
X       88
Z       90
_       95
j       106
~       126
</code>
</WRAP>

===== Wednesday =====

TBD

===== Thursday =====

TBD

===== Friday =====

TBD