C++ Functions: Parameter Passing, RVO, noexcept, Overloading & Defaulted Arguments (C++23)

// Optimal — int, double, float, bool, char all fit in registers
void process_score(int score, double factor, bool normalize) { /*...*/ }

// Optimal for small structs (fits in 2-3 registers)
struct Point { float x, y; };  // 8 bytes — register-eligible
void draw_point(Point p) { /* p.x, p.y in registers */ }

// Sink parameter: function unconditionally stores the value
class Logger {
    std::vector<std::string> messages_;
public:
    // Pass by value: caller decides whether to copy or move
    void log(std::string message) {             // ONE overload handles both:
        messages_.push_back(std::move(message));// Store the message
    }
    // If caller does: logger.log("literal") → move-constructed from temp
    // If caller does: logger.log(my_str)    → copy then move
    // If caller does: logger.log(std::move(my_str)) → move only
};

#include <string>
#include <vector>

// NO copy of the string — just a reference
void log_error(const std::string& message) {
    std::cerr << "[ERROR] " << message << '\n';
}

// Processes entire vector without copying any element
double compute_mean(const std::vector<double>& data) {
    if (data.empty()) return 0.0;
    double sum = 0.0;
    for (const auto& v : data) sum += v;
    return sum / static_cast<double>(data.size());
}

// const& extends lifetime of temporaries:
const std::string& greet() {
    return "Hello"; // ERROR: dangling reference to temporary!
}
const std::string& r = std::string("Hello"); // OK: lifetime extended

#include <memory>
#include <utility>

class Connection {
public:
    Connection() = default;
    Connection(Connection&&) noexcept = default;
};

class ConnectionPool {
    std::vector<Connection> connections_;
public:
    // Explicitly accepts only rvalues — caller MUST move
    void add(Connection&& conn) {
        connections_.push_back(std::move(conn));
    }
};

// Usage:
Connection c;
pool.add(std::move(c));      // OK: explicitly moved
pool.add(Connection{});      // OK: temporary is rvalue
// pool.add(c);             // ERROR: c is an lvalue, must use std::move

#include <vector>

// NRVO applies: the vector 'result' is constructed directly in the caller's space
// Zero copy, zero move — elided by definition
std::vector<int> create_dataset(int size) {
    std::vector<int> result;    // NRVO kicks in:
    result.reserve(size);       // This vector IS the caller's variable
    for (int i = 0; i < size; i++) result.push_back(i * i);
    return result;              // No copy or move!
}

// RVO (guaranteed since C++17): returning a pure temporary
std::vector<int> make_empty() {
    return std::vector<int>{1, 2, 3, 4, 5};  // C++17: GUARANTEED zero copy
}

// Using the results:
auto data  = create_dataset(1000000); // 8MB of data — zero copy!
auto small = make_empty();            // Guaranteed elision

struct Immovable {
    Immovable() = default;
    Immovable(Immovable&&) = delete;
    Immovable(const Immovable&) = delete;
};
Immovable create() { return Immovable{}; } // OK since C++17!
auto obj = create(); // Guaranteed — no move needed

class BigBuffer {
    std::unique_ptr<char[]> data_;
    size_t size_;
public:
    BigBuffer(size_t n) : data_(std::make_unique<char[]>(n)), size_(n) {}
    
    // noexcept move constructor — CRITICAL for vector performance
    BigBuffer(BigBuffer&& other) noexcept
        : data_(std::move(other.data_)), size_(other.size_) {
        other.size_ = 0;
    }
    
    // noexcept move assignment
    BigBuffer& operator=(BigBuffer&& other) noexcept {
        if (this != &other) {
            data_ = std::move(other.data_);
            size_ = other.size_;
            other.size_ = 0;
        }
        return *this;
    }
};

// Test if a function is noexcept at compile time:
static_assert(std::is_nothrow_move_constructible_v<BigBuffer>);

// Without noexcept on move constructor:
std::vector<BigBuffer> v;
v.push_back(BigBuffer(1024)); // Would COPY (expensive!) instead of move
// With noexcept: MOVES — orders of magnitude faster for large buffers

#include <expected>
#include <string>
#include <charconv>

enum class ParseError { EmptyString, InvalidFormat, Overflow };

std::expected<int, ParseError> parse_int(std::string_view s) {
    if (s.empty()) return std::unexpected(ParseError::EmptyString);
    
    int result;
    auto [ptr, ec] = std::from_chars(s.data(), s.data() + s.size(), result);
    
    if (ec == std::errc::result_out_of_range)
        return std::unexpected(ParseError::Overflow);
    if (ec != std::errc{} || ptr != s.data() + s.size())
        return std::unexpected(ParseError::InvalidFormat);
    
    return result;  // Success
}

void use_it() {
    auto result = parse_int("42");
    if (result) {
        std::cout << "Parsed: " << *result << '\n';
    } else {
        switch (result.error()) {
            case ParseError::EmptyString:    std::cerr << "Empty input\n"; break;
            case ParseError::InvalidFormat:  std::cerr << "Bad format\n"; break;
            case ParseError::Overflow:       std::cerr << "Overflow\n"; break;
        }
    }
    
    // Monadic operations (C++23):
    auto doubled = parse_int("21")
        .and_then([](int n) -> std::expected<int, ParseError> {
            return n * 2;
        });
}