This Week

• 1
  Structure of a C++ program
• 2
  Compilation pipeline
• 3
  Types, variables, I/O
• 4
  Functions
• 5
  Pointers KEY
• 6
  Arrays
• 7
  C++ vs. Python

Your First C++ Program

int main() {


    return 0;
}
  

Your First C++ Program

#include <iostream>
using namespace std;

int main() {
    cout << "Hello, World!" << endl;
    return 0;
}
  

Anatomy of a C++ Program

#include <iostream>
using namespace std;

int main() {
    cout << "Hello, World!" << endl;
    return 0;
}
    

Compilation Pipeline

Headers and Translation Units

• A. Create an executable program from source code.
• B. Check the source code for errors.
• C. Pull in required libraries.
• D. A and B only.
• E. B and C only.
• F. A, B, and C.
• G. None of the above.

Data Types & Sizes

cout << sizeof(int);      // 4: check any type yourself
cout << sizeof(double);   // 8
cout << sizeof(grade);    // 1: works on variables too
  

Python vs. C++: Variables

x = 7
      

int x = 7;
      

The Same Variable, Reassigned

x = 3.14
      

x = 3.14;
      

Declare, Then Initialize

...
int    count;             // declared: NOT initialized
int    total  = 0;        // declared and initialized
double pi     = 3.14159;
char   grade  = 'A';
bool   ready  = true;
string name   = "Ada";

cout << "count: " << count << endl;   // ⚠️ undefined: could print anything
cout << "total: " << total << endl;   // always 0
...
  

int x = 11;
x = "12";
  

• A. Yes
• B. No
• C. Yes, but with warnings.

Using const

const int    MAX_SIZE = 100;
const double PI       = 3.14159265;

MAX_SIZE = 200;  // ❌ compiler error: read-only!
  

• Put const before the type to make a variable read-only
• The compiler rejects any code that tries to change it
• Convention: use ALL_CAPS names for constants

Input / Output

#include <iostream>
using namespace std;

int main() {
    double value;
    cout << "Enter a number: ";   // output → terminal
    cin  >> value;                // input  ← terminal
    cerr << "got " << value << endl; // error stream

    cout << "You entered: " << value << endl;
    return 0;
}
  

Streams

File I/O

#include <iostream>
#include <fstream>    // ifstream reads a file, ofstream writes one
#include <cmath>      // sqrt
#include <cassert>
using namespace std;

int main() {
    ifstream fin("numbers.txt");  // open the file, attach a stream to it
    assert(fin.is_open());        // a missing file is not an error to ignore

    double n;                     // ONE variable, reused for every number
    while (fin >> n) {            // read the next number; false when none left
        cout << sqrt(n) << endl;  // fin has already moved past that number
    }

    fin.close();                  // hand the file back to the OS
    return 0;
}
  

What fin >> n Actually Does

Decimal, Binary, Hexadecimal

int x = 33;        // decimal  (default)
int y = 0x21;      // hex:    2×16 + 1 = 33
int z = 0b100001;  // binary: 1×32 + 1 = 33

cout << x << " " << y << " " << z << endl;
// Output:  33 33 33
  

• 0x prefix → hexadecimal (base 16)
• 0b prefix → binary (base 2)
• Memory addresses are typically displayed in hex

Meet Rocky

Not this Rocky.

Prof. Rocky Chang, our department

THIS Rocky!

Rocky, an Eridian, from Project Hail Mary

Why Ten?

Three limbs down, two up: two hands of three fingers, so he counts in sixes.

Functions

Write the tests before the function; it forces you to think about what it should do:

assert(factorial(0) == 1);
assert(factorial(1) == 1);
assert(factorial(4) == 24);
assert(factorial(5) == 120);
  

Functions

unsigned factorial(unsigned n) {
    unsigned result = 1;
    for (unsigned i = 2; i <= n; ++i) {
        result *= i;
    }
    return result;
}

int main() {
    assert(factorial(0) == 1);
    assert(factorial(1) == 1);
    assert(factorial(4) == 24);
    assert(factorial(5) == 120);
    cout << "All tests passed!" << endl;
    return 0;
}
  

Pointers

Memory is a row of numbered boxes. A variable is one box.

int y = 77;
  

Pointers

& ("address-of") hands you the number of a box.

int y  = 77;
int *x = &y;   // x holds the address of y
  

Pointers: Dereferencing

* means "go to that address".

int y  = 77;
int *x = &y;

cout << x;    // 0x1004: the address itself
cout << *x;   // 77:     follow the arrow
*x = 99;      // write at the far end of the arrow
cout << y;    // 99:     y changed, without naming y
  

int y = 77;    // placed at address 0x1004
int *x = &y;  // placed at address 0x1010
cout << x;
    

• A. 77
• B. 0x1004
• C. 0x1010
• D. Error

int y = 77;
int *x = &y;
cout << *y;   // note: *y, not *x
    

• A. 77
• B. 0x12345678
• C. 0x1010
• D. Compile error

int y = 77;
int *x = &y;
cout << *x;
    

• A. 77
• B. 0x12345678
• C. 0x1010
• D. Error

int y = 77;
int *x = &y;
*x = 78;
cout << *x;
    

• A. 77
• B. 78
• C. 0x1010
• D. Error

int y = 77;
int *x = &y;
*x = 78;
cout << y;    // note: y, not *x
    

• A. 77
• B. 78
• C. 0x1010
• D. Error

Arrays

Like Python lists, but fixed size and no bounds checking.

char  letters[26];            // 26 chars, uninitialized
float scores[10] = { 0 };     // all 0.0
int   vals[] = { 10, 9, 4, 2, 0 };  // size inferred: 5
  

• Size must be known at compile time (for stack arrays)
• Indexes: 0 to n−1
• Accessing out of bounds → undefined behavior, no crash guaranteed

Arrays: Memory Layout

int arr[6] = { 1, 3, 5, 2, 77, -11 };
  

Pointers & Arrays

int arr[] = { 3, -11, 4, 12 };
int *ptr  = &arr[2];              // ptr points at arr[2]

cout << *ptr       << endl;      // this box
cout << *(ptr + 1) << endl;      // one int further along
cout << *(ptr - 1) << endl;      // one int back
  

int arr[] = { 3, -11, 4, 12 };
int *ptr  = &arr[2];
cout << *ptr;
    

• A. 3
• B. 2
• C. 4
• D. -11

C++ vs. Python: Core Differences

C++ vs. Python: More Differences