C++ Basics: History, Compiler, Hello World & Namespace Masterclass

// Single-line comment — ignored by compiler
/* Multi-line
   comment */

#include <iostream>   // Preprocessor: include iostream header (cin, cout, cerr)
#include <string>     // std::string
#include <cstdlib>    // EXIT_SUCCESS, EXIT_FAILURE

// Namespace: 'main' lives in global namespace
// All standard library things live in std:: namespace
int main() {           // Entry point: OS calls main() to start program
                       // int = return type (exit code: 0 = success)

    std::cout              // Standard output stream (console)
        << "Hello, World!" // stream insertion operator — feeds string into cout
        << "
";           // newline (
 is faster than std::endl which also flushes)

    std::cout << "C++ " << 2024 << " is amazing!
";

    // Using 'using' to avoid std:: prefix
    using std::cout;
    using std::string;

    string name = "Bjarne Stroustrup";
    cout << "C++ created by: " << name << "
";

    // Reading input
    cout << "Enter your name: ";
    string userName;
    std::cin >> userName;         // reads one word (stops at whitespace)
    cout << "Hello, " << userName << "!
";

    // std::endl vs '
'
    cout << "Using endl (flushes buffer): " << std::endl;  // slower
    cout << "Using \n (no flush):       " << "
";        // faster

    // stderr (unbuffered, for errors)
    std::cerr << "This goes to standard error
";

    return 0;  // Tell OS: success. Use 1 for failure, EXIT_SUCCESS/EXIT_FAILURE
}

#include <iostream>
#include <string>

// Define your own namespace
namespace Math {
    const double PI = 3.14159265358979;

    double circleArea(double r) { return PI * r * r; }
    double circlePerimeter(double r) { return 2 * PI * r; }

    // Nested namespace (C++17 shorthand)
    namespace Trig {
        double degreesToRadians(double deg) { return deg * PI / 180.0; }
    }
}

namespace IO {
    void printSeparator(int n = 40) {
        for (int i = 0; i < n; ++i) std::cout << '-';
        std::cout << '
';
    }
}

int main() {
    // Fully qualified names
    std::cout << Math::PI << "
";
    std::cout << Math::circleArea(5.0) << "
";
    std::cout << Math::Trig::degreesToRadians(90) << "
";

    // using declaration — bring one name into scope
    using std::cout;
    using std::string;
    cout << "cout without std::
";

    // using directive — bring entire namespace into scope (avoid in headers!)
    {
        using namespace Math;
        cout << "PI = " << PI << "
";  // no Math:: needed
        cout << "Area(r=3) = " << circleArea(3.0) << "
";
    }
    // Outside the block, Math:: required again

    IO::printSeparator();
    cout << "Namespaces help organize code!
";
    IO::printSeparator();
    return 0;
}

// ─── mymath.h ─────────────────────────────────────────────────────────────────
// Traditional include guard
#ifndef MYMATH_H
#define MYMATH_H

// OR modern equivalent (supported by all major compilers):
// #pragma once

namespace MyMath {
    double square(double x);     // declaration only in header
    double cube(double x);
    int factorial(int n);
}

#endif  // MYMATH_H

// ─── mymath.cpp ───────────────────────────────────────────────────────────────
// #include "mymath.h"   // include your header (quotes for local files)
// #include <cmath>      // angle brackets for system headers

// namespace MyMath {
//     double square(double x) { return x * x; }
//     double cube(double x)   { return x * x * x; }
//     int factorial(int n)    { return n <= 1 ? 1 : n * factorial(n-1); }
// }

// ─── main.cpp ─────────────────────────────────────────────────────────────────
#include <iostream>
// #include "mymath.h"

// Common standard headers:
// <iostream>   — cin, cout, cerr
// <string>     — std::string
// <vector>     — std::vector
// <array>      — std::array
// <map>        — std::map
// <set>        — std::set
// <algorithm>  — sort, find, transform, etc.
// <cmath>      — sqrt, pow, sin, cos, etc.
// <cassert>    — assert()
// <limits>     — numeric_limits
// <memory>     — unique_ptr, shared_ptr
// <functional> — std::function, std::bind
// <thread>     — std::thread
// <mutex>      — std::mutex

int main() {
    // MyMath::square(4.0);  // would work with the header
    std::cout << "Header files organize declarations!
";
    return 0;
}

#include <iostream>
#include <cassert>

// SYNTAX ERROR (uncomment to see compiler error):
// int x = 5     // missing semicolon

// RUNTIME ERROR (undefined behaviour, may crash):
// int arr[5]; arr[10] = 99; // out of bounds

// LOGIC ERROR (compiles, wrong answer):
double badAverage(int a, int b) {
    return a + b / 2;   // Wrong! Operator precedence: b/2 first, then +a
}

double goodAverage(int a, int b) {
    return (a + b) / 2.0;  // Correct
}

// Using assert for defensive programming
void processAge(int age) {
    assert(age >= 0 && age <= 150 && "Age must be 0-150");
    std::cout << "Processing age: " << age << "
";
}

int main() {
    std::cout << "badAverage(10, 20)  = " << badAverage(10, 20)  << "
";  // 20 (WRONG!)
    std::cout << "goodAverage(10, 20) = " << goodAverage(10, 20) << "
"; // 15 (correct)

    processAge(25);     // OK
    // processAge(-5);  // ASSERT FAILS — catches logic error at runtime
    return 0;
}