C++ for Python and Java Developers

# Python: b and a point to the same list
a = [1, 2, 3]
b = a
b[0] = 99
print(a)   # [99, 2, 3] — a is affected!

// Java: b and a reference the same Point
Point a = new Point(1, 2);
Point b = a;
b.x = 99;
System.out.println(a.x);   // 99 — a is affected!

// C++: b is an independent copy of a
#include <vector>

std::vector<int> a = {1, 2, 3};
std::vector<int> b = a;   // deep copy — independent object
b[0] = 99;
// a is still {1, 2, 3}

std::vector<int> a = {1, 2, 3};
std::vector<int>& b = a;   // b is an alias for a
b[0] = 99;
// a is now {99, 2, 3}

# Python: file closed by GC eventually (or by __exit__ with 'with')
f = open("log.txt", "w")
f.write("hello")
# f is closed... sometime

// C++: file closed exactly when ofstream goes out of scope
#include <fstream>

void write_log() {
    std::ofstream f("log.txt");   // opens on construction
    f << "hello\n";
    // ~ofstream() closes the file here — always, even if an exception is thrown
}

#include <memory>

// WRONG (Java habit):
Widget* w = new Widget(id);  // you must delete this manually
// ... easy to forget, easy to double-delete

// RIGHT:
auto w = std::make_unique<Widget>(id);  // sole owner; auto-deleted when w goes out of scope
auto s = std::make_shared<Widget>(id);  // shared ownership; deleted when last owner is gone

# Python: type error at runtime
def double(x):
    return x * 2

double("hello")   # returns "hellohello" — silently wrong
double(3)         # returns 6

// C++: type error at compile time
int double_val(int x) { return x * 2; }

double_val("hello");   // compile error: cannot convert const char* to int
double_val(3);         // 6

auto x = 42;          // x is int — deduced at compile time
auto s = std::string{"hello"};   // s is std::string

// auto doesn't erase types; it deduces them
auto result = x + s;  // compile error: can't add int + string

# Python: one function works for any type (duck typing)
def square(x):
    return x * x

// C++: template generates a version for each type at compile time
template<typename T>
T square(T x) { return x * x; }

square(3);    // instantiates square<int>
square(3.0);  // instantiates square<double>
// No virtual dispatch, no type erasure — inlined by the compiler

// Stack allocation — fast, automatic cleanup
void process() {
    std::string name = "Alice";      // on the stack
    std::vector<int> data = {1,2,3}; // vector control block on stack, data on heap
    // Both destroyed automatically when process() returns
}

// Heap allocation — when lifetime must outlive the scope
auto widget = std::make_unique<Widget>(id);   // on the heap, owned by unique_ptr on stack

// Java: everything is newed
Widget w = new Widget(42);

// C++ — stack (preferred)
Widget w{42};           // on the stack, destroyed automatically

// C++ — heap with ownership (use when needed)
auto w = std::make_unique<Widget>(42);   // heap, auto-deleted

# Python list: heterogeneous, reference-based
items = [1, "hello", 3.14, [1,2]]

// std::vector<T>: homogeneous, value-based
std::vector<int>    ints   = {1, 2, 3};
std::vector<std::string> words = {"hello", "world"};

// Heterogeneous: use std::variant or std::any
std::vector<std::variant<int, std::string>> mixed = {1, "hello", 3};

// Java HashMap<K,V>: K and V are object references
Map<String, Integer> m = new HashMap<>();

// std::unordered_map<K,V>: K and V are values (no boxing)
std::unordered_map<std::string, int> m;
m["key"] = 42;
// Accessing a missing key creates a default-initialized value (0 for int)
// Use m.find() or m.contains() to check first

std::vector<int> v = {1, 2, 3};
for (int x : v) {
    v.push_back(x * 2);  // UB! push_back may reallocate, invalidating the range-for iterator
}

# Python: return None to signal "no value"
def find_user(id):
    if id not in db:
        return None
    return db[id]

user = find_user(42)
if user is not None:
    print(user.name)

#include <optional>

std::optional<User> find_user(int id) {
    if (!db.contains(id)) return std::nullopt;
    return db[id];
}

auto user = find_user(42);
if (user) {                    // bool conversion
    std::println("{}", user->name);
}

// Or with a default:
User u = find_user(42).value_or(default_user);

# Python: exceptions as flow control (idiomatic there, not in C++)
try:
    value = my_dict["key"]
except KeyError:
    value = default_value

// C++: check before accessing
auto it = my_map.find("key");
if (it != my_map.end()) {
    value = it->second;
} else {
    value = default_value;
}

// Or C++20:
value = my_map.contains("key") ? my_map.at("key") : default_value;

// Java: always reference semantics, polymorphism works
Animal a = new Dog();
a.speak();   // "Woof" — correct

// C++: value semantics slices the object
struct Animal {
    virtual std::string speak() const { return "..."; }
    virtual ~Animal() = default;
};

struct Dog : Animal {
    std::string speak() const override { return "Woof"; }
};

Dog d;
Animal a = d;       // SLICED: a is an Animal value, Dog portion discarded
a.speak();          // returns "..." — not "Woof"!

// FIX: use pointer or reference for polymorphism
Animal& ar = d;     // reference — not sliced
ar.speak();         // "Woof"

std::unique_ptr<Animal> pa = std::make_unique<Dog>();
pa->speak();        // "Woof"

#include <cstdint>

int32_t  i32 = -1'000'000;   // guaranteed 32-bit signed
uint64_t u64 = 18'446'744'073'709'551'615ULL;  // guaranteed 64-bit unsigned
int8_t   byte = 127;

// Platform-size types (avoid in serialization/networking):
int    x;    // at least 16-bit; usually 32-bit
long   y;    // 32-bit on Windows 64-bit, 64-bit on Linux 64-bit

int x = INT_MAX;
x + 1;   // UB in C++ — do NOT rely on this wrapping to 0
          // use unsigned or check before adding