C++ Functions: Syntax, Overloading, Lambdas, Templates & Recursion — Complete Guide (2025)

#include <iostream>
#include <string>
using namespace std;

// ── Declaration (prototype) — needed if definition is AFTER main ─
int  add(int a, int b);
void greet(const string& name);

int main() {
    cout << add(3, 5) << endl;  // 8
    greet("Alice");              // Hello, Alice!
    return 0;
}

// ── Definitions (can come after main if prototype exists above) ──
int add(int a, int b) {
    return a + b;
}

void greet(const string& name) {
    cout << "Hello, " << name << "!\n";
    // no return statement — void function
}

#include <iostream>
#include <vector>
#include <utility>  // std::move
using namespace std;

// 1. By VALUE — cannot modify caller's variable
void byValue(int x) { x = 99; }   // caller's x unchanged

// 2. By REFERENCE — modifies caller's variable
void byRef(int& x) { x = 99; }   // caller's x IS changed

// 3. By CONST REF — read-only, no copy (efficient for strings/vectors)
void byConstRef(const string& s) {
    cout << "len=" << s.length() << endl;  // read only
}

// 4. By POINTER — can be null
void byPointer(int* p) {
    if (p) *p = 99;  // always null-check
}

// 5. By MOVE — transfer ownership, caller's object is emptied
void byMove(vector<int>&& v) {
    vector<int> local = move(v);  // steal v's data
    cout << "Received " << local.size() << " elements\n";
}

int main() {
    int a = 5;
    byValue(a);   cout << a << endl;  // 5 — unchanged
    byRef(a);     cout << a << endl;  // 99 — changed
    byConstRef("Hello World");        // len=11, no copy

    int b = 10;
    byPointer(&b); cout << b << endl; // 99

    vector<int> v = {1,2,3};
    byMove(move(v));
    cout << v.size() << endl;        // 0 — moved-out
    return 0;
}

#include <iostream>
#include <string>
using namespace std;

// Three overloads — same name, different parameter types
int    add(int a, int b)          { return a + b; }
double add(double a, double b)    { return a + b; }
string add(const string& a, const string& b) { return a + b; }

// Overloading on number of parameters
int multiply(int a, int b)          { return a * b; }
int multiply(int a, int b, int c)  { return a * b * c; }

// ⚠ Return type alone does NOT distinguish overloads — compile error!
// int  getData();   ← ERROR: ambiguous with the double version below
// double getData();

int main() {
    cout << add(3, 5)             << endl;  // 8      — int version
    cout << add(3.0, 5.0)         << endl;  // 8      — double version
    cout << add("Hello", " World") << endl;  // Hello World
    cout << multiply(2, 3)         << endl;  // 6
    cout << multiply(2, 3, 4)      << endl;  // 24
    return 0;
}

#include <iostream>
#include <string>
using namespace std;

// Default arguments must be RIGHT-TO-LEFT
// ✓ correct: rightmost params get defaults first
void log(const string& msg,
          int           level     = 1,
          bool          timestamp = true)
{
    if (timestamp) cout << "[TS] ";
    cout << "L" << level << ": " << msg << endl;
}

// ✗ ILLEGAL: non-trailing default
// void bad(int x = 0, int y);  ← compile error

// Real-world: connection with sensible defaults
bool connect(const string& host,
              int           port    = 443,
              bool          secure  = true,
              int           timeout = 30)
{
    cout << (secure ? "https" : "http") << "://"
         << host << ":" << port
         << " (timeout=" << timeout << "s)\n";
    return true;
}

int main() {
    log("App started");           // level=1, timestamp=true
    log("Debug info", 3);         // level=3, timestamp=true
    log("No stamp", 1, false);    // timestamp=false

    connect("api.example.com");    // all defaults
    connect("api.example.com", 80, false);  // http
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;

int main() {
    // ── Basic lambda ───────────────────────────────────────────
    auto square = [](int x) { return x * x; };
    cout << square(5) << endl;  // 25

    // ── Capture by value [=] and by reference [&] ─────────────
    int factor = 3;
    auto multiply = [factor](int x) { return x * factor; };  // copies factor
    auto addToFactor = [&factor](int x) { factor += x; };       // modifies factor

    cout << multiply(4) << endl;  // 12
    addToFactor(10); cout << factor << endl;  // factor = 13

    // ── Lambda in STL algorithms ───────────────────────────────
    vector<int> v = {5, 2, 8, 1, 9, 3};

    // Sort descending
    sort(v.begin(), v.end(), [](int a, int b) { return a > b; });
    for (int x : v) cout << x << " ";  cout << endl;  // 9 8 5 3 2 1

    // Count elements greater than 4
    int count = count_if(v.begin(), v.end(), [](int x){ return x > 4; });
    cout << "Count > 4: " << count << endl;  // 3

    // ── std::function — type-erased callable ──────────────────
    function<int(int,int)> op;
    op = [](int a, int b) { return a + b; };
    cout << op(3, 5) << endl;   // 8
    op = [](int a, int b) { return a * b; };
    cout << op(3, 5) << endl;   // 15

    return 0;
}

#include <iostream>
#include <string>
using namespace std;

// ── Function template — works for any comparable type ─────────
template<typename T>
const T& maxVal(const T& a, const T& b) {
    return a > b ? a : b;
}

// ── Template with multiple type parameters ────────────────────
template<typename T, typename U>
auto add(T a, U b) -> decltype(a + b) {
    return a + b;
}

// ── constexpr — computed at compile time ──────────────────────
constexpr long long factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}

// ── inline — zero-overhead small functions ────────────────────
inline int square(int x) noexcept { return x * x; }

// ── [[nodiscard]] — warn if return value is ignored ───────────
[[nodiscard]] int computeChecksum(const string& s) noexcept {
    int sum = 0;
    for (char c : s) sum += c;
    return sum;
}

int main() {
    // Template: compiler generates maxVal and maxVal
    cout << maxVal(10, 20)        << endl;  // 20
    cout << maxVal(3.14, 2.71)   << endl;  // 3.14
    cout << maxVal(string("Z"), string("A")) << endl;  // Z

    // Mixed types
    cout << add(3, 4.5) << endl;  // 7.5 (int+double → double)

    // constexpr: computed at compile time — same as a constant
    constexpr long long f10 = factorial(10);  // compile-time!
    cout << f10 << endl;  // 3628800

    cout << square(7) << endl;  // 49

    auto cs = computeChecksum("hello");  // [[nodiscard]] — must use
    cout << cs << endl;
    return 0;
}

#include <iostream>
using namespace std;

// ── Factorial — classic recursion ──────────────────────────────
long long factorial(int n) {
    if (n <= 1) return 1;          // ① base case — STOP condition
    return n * factorial(n - 1);   // ② recursive case — smaller input
}

// ── Fibonacci — recursive (exponential) ───────────────────────
long long fibRec(int n) {
    if (n <= 1) return n;
    return fibRec(n-1) + fibRec(n-2);  // O(2^n) — slow for large n!
}

// ── Fibonacci — iterative (linear) ────────────────────────────
long long fibIter(int n) {
    if (n <= 1) return n;
    long long prev = 0, curr = 1;
    for (int i = 2; i <= n; i++) {
        long long next = prev + curr;
        prev = curr; curr = next;
    }
    return curr;
}

// ── Tail recursion — accumulator pattern ──────────────────────
long long factTail(int n, long long acc = 1) {
    if (n <= 1) return acc;      // base: return accumulated result
    return factTail(n-1, n*acc);  // tail call — GCC optimizes to loop
}

int main() {
    cout << factorial(10)         << endl;  // 3628800
    cout << factTail(10)          << endl;  // 3628800
    cout << fibRec(10)             << endl;  // 55
    cout << fibIter(10)            << endl;  // 55
    cout << fibIter(50)            << endl;  // 12586269025 (fast)
    return 0;
}