ఆపరేటర్ ఓవర్‌లోడింగ్ & Friends

#include <iostream>

class ComplexNumber {
public:
    double real;
    double imag;

    ComplexNumber(double r = 0.0, double i = 0.0) : real(r), imag(i) {}

    // Binary + Operator Overloading (Member Function)
    ComplexNumber operator+(const ComplexNumber& rhs) const {
        return ComplexNumber(this->real + rhs.real, this->imag + rhs.imag);
    }

    // Binary - Operator Overloading
    ComplexNumber operator-(const ComplexNumber& rhs) const {
        return ComplexNumber(this->real - rhs.real, this->imag - rhs.imag);
    }

    void display() const {
        std::cout << real << " + " << imag << "i\n";
    }
};

int main() {
    ComplexNumber c1(4.5, 3.2);
    ComplexNumber c2(1.5, 2.8);

    // సహజమైన గణిత సంకలనం!
    ComplexNumber sum = c1 + c2; // అంతర్గతంగా c1.operator+(c2) గా మారుతుంది!
    ComplexNumber diff = c1 - c2;

    std::cout << "c1 + c2 మొత్తం: "; sum.display();
    std::cout << "c1 - c2 తేడా:   "; diff.display();
    return 0;
}

#include <iostream>

class Dimension {
public:
    int length;
    int breadth;

    Dimension(int l, int b) : length(l), breadth(b) {}

    // Equality Operator
    bool operator==(const Dimension& rhs) const {
        return (length == rhs.length && breadth == rhs.breadth);
    }

    bool operator!=(const Dimension& rhs) const {
        return !(*this == rhs); // == పై ఆధారపడి సులభంగా రీయూజ్!
    }
};

int main() {
    Dimension d1(10, 20);
    Dimension d2(10, 20);
    Dimension d3(15, 30);

    std::cout << "d1 == d2? " << (d1 == d2 ? "సమానం (True)" : "అసమానం (False)") << "\n";
    std::cout << "d1 != d3? " << (d1 != d3 ? "అసమానం (True)" : "సమానం (False)") << "\n";
    return 0;
}

#include <iostream>
#include <string>

class StockItem {
private:
    std::string itemName;
    double price;
    int stockQuantity;

public:
    StockItem(std::string name, double p, int qty) : itemName(name), price(p), stockQuantity(qty) {}

    // friend stream insertion operator
    friend std::ostream& operator<<(std::ostream& os, const StockItem& item) {
        os << "[ఉత్పత్తి: " << item.itemName << " | ధర: ₹ " << item.price << " | నిల్వ: " << item.stockQuantity << " యూనిట్లు]";
        return os; // చైనింగ్ (cout << a << b) కొరకు os రిటర్న్ చేయాలి!
    }
};

int main() {
    StockItem item1("Sony PlayStation 5", 54990.0, 15);
    StockItem item2("LG OLED 4K TV", 89990.0, 8);

    // అందమైన స్ట్రీమ్ ప్రింటింగ్!
    std::cout << item1 << "\n" << item2 << "\n";
    return 0;
}

#include <iostream>
#include <string>

class BankVault; // ఫార్వర్డ్ డిక్లరేషన్

class VaultAuditor {
public:
    void auditAccount(const BankVault& vault);
};

class BankVault {
private:
    std::string secretKey = "VAULT_SECRET_9876";
    double reserveCash = 50000000.0;

    // VaultAuditor క్లాస్‌ను అధికారిక 'friend' గా ప్రకటిస్తున్నాం!
    friend class VaultAuditor;
};

void VaultAuditor::auditAccount(const BankVault& vault) {
    // friend అయినందున ప్రైవేట్ డేటాను నేరుగా చదవగలదు!
    std::cout << "  🔍 [RBI ఆడిట్] రహస్య కీ: " << vault.secretKey << "\n";
    std::cout << "  💰 [RBI ఆడిట్] వాల్ట్ నగదు నిల్వ: ₹ " << vault.reserveCash << "\n";
}

int main() {
    BankVault vault;
    VaultAuditor auditor;
    auditor.auditAccount(vault);
    return 0;
}

#include <iostream>
#include <stdexcept>

class SafeBuffer {
private:
    int data[5] = {10, 20, 30, 40, 50};

public:
    int& operator[](size_t index) {
        if (index >= 5) {
            throw std::out_of_range("❌ ఎర్రర్: బఫర్ బౌండరీ దాటిపోయింది!");
        }
        return data[index];
    }

    const int& operator[](size_t index) const {
        if (index >= 5) {
            throw std::out_of_range("❌ ఎర్రర్: బఫర్ బౌండరీ దాటిపోయింది!");
        }
        return data[index];
    }
};

int main() {
    SafeBuffer buf;
    std::cout << "buf[2] పాత విలువ: " << buf[2] << "\n";

    buf[2] = 999;
    std::cout << "buf[2] కొత్త విలువ: " << buf[2] << "\n";
    return 0;
}

#include <iostream>

class StepCounter {
private:
    int steps;
public:
    StepCounter(int s = 0) : steps(s) {}

    // Prefix Increment: ++counter
    StepCounter& operator++() {
        ++steps;
        return *this; // రిఫరెన్స్ రిటర్న్ - సూపర్ ఫాస్ట్!
    }

    // Postfix Increment: counter++ (డమ్మీ int తో)
    StepCounter operator++(int) {
        StepCounter temp = *this; // పాత కాపీని భద్రపరచడం
        ++steps;                  // ప్రస్తుత విలువ పెంపు
        return temp;              // పాత కాపీని రిటర్న్
    }

    int getSteps() const { return steps; }
};

int main() {
    StepCounter c(10);
    StepCounter pre = ++c; // c -> 11, pre -> 11
    std::cout << "Prefix తర్వాత c: " << c.getSteps() << " | pre: " << pre.getSteps() << "\n";

    StepCounter post = c++; // post -> 11, c -> 12
    std::cout << "Postfix తర్వాత c: " << c.getSteps() << " | post: " << post.getSteps() << "\n";
    return 0;
}

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

// Functor Class
class ThresholdFilter {
private:
    int minThreshold;
public:
    ThresholdFilter(int threshold) : minThreshold(threshold) {}

    // Function call operator () overloading
    bool operator()(int value) const {
        return value >= minThreshold;
    }
};

int main() {
    std::vector<int> scores = {45, 82, 91, 33, 76, 58, 99};

    ThresholdFilter passFilter(60); // 60 కంటే ఎక్కువ ఉన్నవి పాస్!

    int passedStudents = std::count_if(scores.begin(), scores.end(), passFilter);

    std::cout << "మొత్తం విద్యార్థులు: " << scores.size() << "\n";
    std::cout << "60 మార్కులకు పైగా సాధించిన వారు: " << passedStudents << "\n";
    return 0;
}

#include <iostream>
#include <cmath>
#include <iomanip>

class Vector3D {
private:
    double coords[3]; // 0: x, 1: y, 2: z

public:
    Vector3D(double x = 0.0, double y = 0.0, double z = 0.0) {
        coords[0] = x;
        coords[1] = y;
        coords[2] = z;
    }

    // 1. Array Subscript Operator ([]) Overloading
    double& operator[](size_t index) { return coords[index]; }
    const double& operator[](size_t index) const { return coords[index]; }

    // 2. Binary Vector Addition (+)
    Vector3D operator+(const Vector3D& rhs) const {
        return Vector3D(coords[0] + rhs[0], coords[1] + rhs[1], coords[2] + rhs[2]);
    }

    // 3. Binary Vector Subtraction (-)
    Vector3D operator-(const Vector3D& rhs) const {
        return Vector3D(coords[0] - rhs[0], coords[1] - rhs[1], coords[2] - rhs[2]);
    }

    // 4. Scalar Multiplication: Vector * scalar
    Vector3D operator*(double scalar) const {
        return Vector3D(coords[0] * scalar, coords[1] * scalar, coords[2] * scalar);
    }

    // 5. Symmetric Non-member Friend: scalar * Vector
    friend Vector3D operator*(double scalar, const Vector3D& v) {
        return v * scalar; // రీ-యూజ్!
    }

    // 6. Dot Product Multiplication: Vector * Vector
    double dot(const Vector3D& rhs) const {
        return (coords[0] * rhs[0]) + (coords[1] * rhs[1]) + (coords[2] * rhs[2]);
    }

    // 7. Magnitude (Vector Length)
    double magnitude() const {
        return std::sqrt(dot(*this));
    }

    // 8. Equality Operator
    bool operator==(const Vector3D& rhs) const {
        return (coords[0] == rhs[0] && coords[1] == rhs[1] && coords[2] == rhs[2]);
    }

    // 9. Stream Insertion Operator (<<)
    friend std::ostream& operator<<(std::ostream& os, const Vector3D& v) {
        os << "Vector3D(" << v[0] << ", " << v[1] << ", " << v[2] << ")";
        return os;
    }
};

int main() {
    std::cout << "=======================================================================\n";
    std::cout << "🚀 [ENTERPRISE 3D VECTOR MATH & ASTROPHYSICS ENGINE RUNNING]\n";
    std::cout << "=======================================================================\n";

    Vector3D position(10.0, 20.0, 5.0);
    Vector3D velocity(2.5, -1.0, 4.0);

    std::cout << "ప్రారంభ స్థానం (Position) : " << position << "\n";
    std::cout << "ప్రస్తుత వేగం (Velocity)   : " << velocity << "\n";

    // 1 సెకను తర్వాతి స్థానం: pos + vel
    Vector3D nextPos = position + velocity;
    std::cout << "తర్వాతి స్థానం (Next Pos)  : " << nextPos << "\n";

    // స్కేలార్ గుణకారం (3x Velocity Boost): v * 3
    Vector3D boosted = velocity * 3.0;
    std::cout << "3x బూస్ట్ వేగం (Boosted)  : " << boosted << "\n";

    // సిమెట్రిక్ నాన్-మెంబర్ గుణకారం: 2.0 * v
    Vector3D doubleSpeed = 2.0 * velocity;
    std::cout << "డబుల్ స్పీడ్ (2.0 * vel)  : " << doubleSpeed << "\n";

    // డాట్ ప్రొడక్ట్ గణన
    double dotProduct = position.dot(velocity);
    std::cout << "స్థానం మరియు వేగం డాట్ ప్రొడక్ట్: " << dotProduct << "\n";
    std::cout << "వేగం యొక్క పరిమాణం (Speed): " << std::fixed << std::setprecision(2) << velocity.magnitude() << " m/s\n";

    std::cout << "=======================================================================\n";
    std::cout << "✅ ఆపరేటర్ ఓవర్‌లోడింగ్ తో ఫిజిక్స్ వెక్టర్ సిమ్యులేషన్ విజయవంతమైంది!\n";
    std::cout << "=======================================================================\n";
    return 0;
}