Week 01 / 14 Object-Oriented Programming

Review - tooling and memory

How the course works, how to work in Visual Studio, which kinds of errors you will meet, where variables live in memory, and how parameters are passed.

Course structure and assessment

The course runs for 14 weeks, with one lecture and one lab each week. In the labs we write code, break it, and fix it.

There are two live tests in the labs, in weeks 7 and 11. Both are individual, on a computer, and AI-free.

The Visual Studio environment

1. File → New → Project → Console App (C++).
2. Write your code in main.cpp.
3. Build → Build Solution (Ctrl+Shift+B) compiles and links.
4. Debug → Start Without Debugging (Ctrl+F5) runs the program.

Errors show up in the Error List window. The full compiler messages are in the Output window. Always read the first error, because many of the ones after it are only consequences of it.

Kinds of errors

Compile error. The code breaks the rules of the language:

int x = 10
std::cout << x;   // missing ';' on the previous line

Link error. The function is declared, but never defined:

int sum(int a, int b);            // declaration only
int main() { return sum(1, 2); }  // LNK2019: unresolved external symbol

Runtime error. The program compiles, but stops while running:

int* p = nullptr;
*p = 5;   // access through an invalid address

Logical error. The program runs and prints something, but not what you wanted. These are the hardest to find.

#include <iostream>
using namespace std;
int main() {
    int v[3] = {1, 2, 3};
    int s = 0;
    for (int i = 1; i <= 2; i++) s += v[i];
    cout << s;
}

Kinds of memory

• Stack: local variables and parameters live here. They are created when a function starts and destroyed automatically when it returns.
• Heap: memory you request explicitly with new and release explicitly with delete. It lives until you release it.
• Static memory: global and static variables. They live for the whole program.

Debugger and the Memory window

• Breakpoint (F9): execution stops on that line.
• Step Over (F10): runs the current line without entering functions.
• Step Into (F11): enters the called function.
• Watch / Locals / Autos: variable values at the point where execution stopped.
• Debug → Windows → Memory → Memory 1: type an address (e.g. &a or p) and see the bytes stored there.

Before you press F10, say out loud which value you expect to see. Then check.

Passing parameters

#include <iostream>
using namespace std;
void doubleIt(int x) { x = x * 2; }
int main() {
    int a = 5;
    doubleIt(a);
    cout << a;
}

Run and change the program below. What happens if sumByValue takes int& s instead?

#include <iostream>
using namespace std;
void sumByValue(int a, int b, int s) { s = a + b; }
void sumByReference(int a, int b, int& s) { s = a + b; }
void sumByAddress(int* a, int* b, int* s) { *s = *a + *b; }
int main() {
  int x = 3, y = 4, s = 0;
  sumByValue(x, y, s);
  cout << "value: " << s << endl;
  sumByReference(x, y, s);
  cout << "reference: " << s << endl;
  s = 0;
  sumByAddress(&x, &y, &s);
  cout << "address: " << s << endl;
}

Send live: What does the program print?

Check yourself

#include <iostream>
using namespace std;
void f(int x) { x++; }
void g(int& x) { x++; }
int main() {
    int a = 1;
    f(a); g(a); g(a);
    cout << a;
}

#include <iostream>
using namespace std;
void change(int* p) { *p = 10; p = nullptr; }
int main() {
    int a = 1;
    int* q = &a;
    change(q);
    cout << a << " " << (q != nullptr);
}

Code in repository: L01

Romanian version