C++

#include <iostream>
#include <string>
#include <vector>

int main() {
    // C++ streams replace printf
    std::cout << "Hello, World!" << std::endl;

    // std::string — not a char array
    std::string name = "Priya";
    std::cout << "Hello, " << name << "!" << std::endl;

    // std::vector — dynamic array (not a C array)
    std::vector<int> scores = {95, 88, 72, 91};
    scores.push_back(85);

    // Range-based for loop (C++11)
    for (int score : scores) {
        std::cout << score << " ";
    }
    std::cout << std::endl;

    // auto — type inference (C++11)
    auto pi = 3.14159;
    auto message = std::string("typed as string");

    return 0;
}

#include <iostream>
#include <string>
#include <stdexcept>

class BankAccount {
private:
    std::string owner_;   // trailing _ convention for members
    double balance_;

public:
    // Constructor
    BankAccount(std::string owner, double balance)
        : owner_(std::move(owner)), balance_(balance) {}

    // Destructor — runs automatically when object goes out of scope
    ~BankAccount() {
        std::cout << owner_ << " account closed\n";
    }

    void deposit(double amount) {
        if (amount <= 0) throw std::invalid_argument("Amount must be positive");
        balance_ += amount;
    }

    double getBalance() const { return balance_; }  // const = does not modify

    // Operator overloading
    friend std::ostream& operator<<(std::ostream& os, const BankAccount& acc) {
        return os << "Account(" << acc.owner_ << ": " << acc.balance_ << ")";
    }
};

int main() {
    BankAccount acc("Priya", 1000.0);
    acc.deposit(500.0);
    std::cout << acc << std::endl;  // Account(Priya: 1500)
}   // acc.~BankAccount() called automatically here

#include <memory>
#include <fstream>
#include <iostream>

void process_file(const std::string& path) {
    // RAII: file closed automatically when stream goes out of scope
    std::ifstream file(path);
    if (!file.is_open()) throw std::runtime_error("Cannot open: " + path);

    std::string line;
    while (std::getline(file, line)) {
        std::cout << line << "\n";
    }
}   // file.~ifstream() closes the file here — even if exception thrown

void smart_pointers() {
    // unique_ptr: single owner — freed when pointer goes out of scope
    auto p1 = std::make_unique<int>(42);
    std::cout << *p1 << "\n";   // 42
    // p1 freed automatically here

    // shared_ptr: reference-counted — freed when last owner gone
    auto p2 = std::make_shared<std::string>("hello");
    auto p3 = p2;   // both p2 and p3 own the string
    std::cout << p2.use_count() << "\n";  // 2
}   // string freed here when both p2 and p3 destroyed

#include <iostream>
#include <vector>
#include <algorithm>

// Function template
template<typename T>
T max_val(T a, T b) { return a > b ? a : b; }

// Class template
template<typename T>
class Stack {
    std::vector<T> data_;
public:
    void push(T val) { data_.push_back(std::move(val)); }
    T pop() {
        if (data_.empty()) throw std::runtime_error("empty stack");
        T val = std::move(data_.back());
        data_.pop_back();
        return val;
    }
    bool empty() const { return data_.empty(); }
};

// Template with concept constraint (C++20)
template<typename T>
requires std::totally_ordered<T>
T clamp(T val, T lo, T hi) {
    return std::clamp(val, lo, hi);
}

int main() {
    std::cout << max_val(3, 7) << "\n";         // 7 (int)
    std::cout << max_val(3.14, 2.71) << "\n";  // 3.14 (double)

    Stack<std::string> s;
    s.push("hello");
    s.push("world");
    std::cout << s.pop() << "\n";  // world
}