break, continue & లూప్ కంట్రోల్

#include <iostream>
#include <vector>

int main() {
    std::vector<int> userIds = {1024, 2048, 4096, 8192, 16384, 32768, 65536};
    int targetId = 8192;
    int searchComparisons = 0;
    bool isFound = false;

    std::cout << "వెతుకుతున్న యూజర్ ఐడీ: " << targetId << "\n";

    for (size_t i = 0; i < userIds.size(); ++i) {
        ++searchComparisons;
        std::cout << "ఇండెక్స్ [" << i << "] పరిశీలన: ఐడీ " << userIds[i] << "...\n";

        if (userIds[i] == targetId) {
            std::cout << "🎉 ఐడీ విజయవంతంగా లభించింది! ఇండెక్స్: " << i << '\n';
            isFound = true;
            break; // 🛑 బ్రేక్! లక్ష్యం దొరికింది కాబట్టి మిగిలిన అర్రేను వెతకడం ఆపేయండి!
        }
    }

    std::cout << "----------------------------------------------------\n";
    std::cout << "మొత్తం పోలికల సంఖ్య: " << searchComparisons << " (లక్ష్యం లభించిన వెంటనే ఆగిపోయింది)\n";

    return 0;
}

#include <iostream>

int main() {
    int count = 0;

    std::cout << "1 నుండి 10 వరకు 3 యొక్క గుణిజాలను స్కిప్ చేయడం:\n";

    while (count < 10) {
        ++count; // ✅ ఎల్లప్పుడూ continue కి ముందే కౌంటర్‌ను పెంచాలి!

        if (count % 3 == 0) {
            std::cout << "[స్కిప్: " << count << "] ";
            continue; // 3, 6, 9 లు స్కిప్ అవుతాయి కానీ లూప్ సేఫ్ గా ముందుకు సాగుతుంది!
        }

        std::cout << count << " ";
    }

    std::cout << "\nలూప్ విజయవంతంగా ముగిసింది.\n";
    return 0;
}

#include <iostream>
#include <vector>

// 2D మ్యాట్రిక్స్‌లో నంబర్‌ను వెతికే ఫంక్షన్: దొరకగానే నేరుగా return చేస్తుంది!
bool findInMatrix(const std::vector<std::vector<int>>& matrix, int target) {
    for (size_t r = 0; r < matrix.size(); ++r) {
        for (size_t c = 0; c < matrix[r].size(); ++c) {
            if (matrix[r][c] == target) {
                std::cout << "🎯 టార్గెట్ " << target << " రో [" << r << "], కాలమ్ [" << c << "] వద్ద దొరికింది!\n";
                return true; // 🏆 మల్టీ-లెవల్ లూప్‌లన్నింటినీ ఒక్కేసారి బైపాస్ చేసి బయటకు వచ్చేస్తుంది!
            }
        }
    }
    return false; // ఎక్కడా దొరకలేదు
}

int main() {
    std::vector<std::vector<int>> grid = {
        {10, 20, 30},
        {40, 50, 60},
        {70, 80, 90}
    };

    findInMatrix(grid, 50);
    return 0;
}

#include <iostream>

int main() {
    int retryCount = 0;
    const int maxRetries = 4;
    bool isConnected = false;

    std::cout << "🌐 క్లౌడ్ గేట్‌వే సర్వర్‌తో కనెక్ట్ అవ్వడానికి ప్రయత్నిస్తున్నాం...\n";

    // ఇన్ఫైనైట్ లూప్ - కానీ వాచ్‌డాగ్ పరిమితితో సేఫ్ గా నియంత్రించబడింది!
    while (true) {
        ++retryCount;
        std::cout << "ప్రయత్నం #" << retryCount << "... ";

        // 3వ ప్రయత్నంలో సర్వర్ రెస్పాండ్ అయిందని అనుకరిద్దాం
        if (retryCount == 3) {
            std::cout << "✅ కనెక్షన్ విజయవంతమైంది!\n";
            isConnected = true;
            break; // విజయవంతం కాగానే లూప్ టెర్మినేట్ అవుతుంది
        }

        std::cout << "❌ కనెక్షన్ విఫలమైంది.\n";

        // వాచ్‌డాగ్ సేఫ్టీ చెక్: గరిష్ట పరిమితి దాటితే ఎమర్జెన్సీ బ్రేక్!
        if (retryCount >= maxRetries) {
            std::cout << "🛑 వాచ్‌డాగ్ అలర్ట్: గరిష్ట ప్రయత్నాలు పూర్తయ్యాయి. సర్వర్ డౌన్ అయింది!\n";
            break;
        }
    }

    return 0;
}

#include <iostream>
#include <vector>

struct Order {
    int orderId;
    double amount;
    bool isCancelled;
};

int main() {
    std::vector<Order> orders = {
        {101, 1500.0, false},
        {102, -50.0,  false}, // తప్పుడు అమౌంట్
        {103, 3200.0, true},  // క్యాన్సిల్ అయిన ఆర్డర్
        {104, 4500.0, false},
        {105, 0.0,    false}  // ఉచిత ఆర్డర్
    };

    double validRevenue = 0.0;
    int processedCount = 0;

    std::cout << "--- ఈ-కామర్స్ ఆర్డర్ల రెవెన్యూ శానిటైజేషన్ పైప్‌లైన్ ---\n";

    for (const auto& ord : orders) {
        // 1. రద్దయిన ఆర్డర్లను స్కిప్ చేయండి
        if (ord.isCancelled) {
            std::cout << "ఆర్డర్ #" << ord.orderId << " రద్దు చేయబడింది. [స్కిప్]\n";
            continue;
        }

        // 2. అమాన్యమైన రుణ లేదా సున్నా విలువలను స్కిప్ చేయండి
        if (ord.amount <= 0.0) {
            std::cout << "ఆర్డర్ #" << ord.orderId << " అమాన్యమైన మొత్తం: ₹" << ord.amount << " [స్కిప్]\n";
            continue;
        }

        // 3. కేవలం చెల్లుబాటు అయ్యే ఆర్డర్లు మాత్రమే ఇక్కడికి చేరుకుంటాయి!
        validRevenue += ord.amount;
        ++processedCount;
        std::cout << "ఆర్డర్ #" << ord.orderId << " ప్రాసెస్ అయింది: ₹" << ord.amount << '\n';
    }

    std::cout << "-----------------------------------------------------\n";
    std::cout << "విజయవంతంగా లెక్కించిన మొత్తం రెవెన్యూ: ₹" << validRevenue << '\n';
    return 0;
}

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

// నెట్‌వర్క్ ప్యాకెట్ డేటా నిర్మాణం
struct NetworkPacket {
    int packetId;
    std::string sourceIp;
    int destPort;
    std::string payload;
    int threatScore; // 0 నుండి 100 వరకు రిస్క్ స్కోర్
};

int main() {
    std::vector<NetworkPacket> packetStream = {
        {1001, "192.168.1.15", 443,  "GET /secure/dashboard HTTPS", 5},
        {1002, "10.0.0.45",    80,   "HEALTH_CHECK_PING",           0},
        {1003, "172.16.0.88",  22,   "SSH_BRUTE_FORCE_PAYLOAD",     85},
        {1004, "192.168.1.18", 8080, "NORMAL_API_JSON_REQUEST",    10},
        {1005, "45.33.32.156", 445,  "MALWARE_RANSOMWARE_SIGNATURE",98}, // తీవ్రమైన సైబర్ దాడి!
        {1006, "192.168.1.99", 443,  "USER_IMAGE_UPLOAD",           12}
    };

    std::cout << "========================================================================================\n";
    std::cout << "       🛡️ CLOUDSHIELD ENTERPRISE NEXT-GEN FIREWALL & PACKET INSPECTION ENGINE           \n";
    std::cout << "========================================================================================\n";
    std::cout << std::left << std::setw(10) << "ప్యాకెట్ ID" 
              << std::setw(18) << "సోర్స్ IP" 
              << std::setw(8)  << "పోర్ట్" 
              << std::setw(14) << "రిస్క్ స్కోర్" 
              << "ఫైర్‌వాల్ చర్య (Firewall Action)\n";
    std::cout << "----------------------------------------------------------------------------------------\n";

    int inspectedPackets = 0;
    int passedPackets = 0;
    int droppedPackets = 0;
    bool emergencyLockdown = false;

    // నెట్‌వర్క్ ప్యాకెట్ల స్ట్రీమ్‌ను పరిశీలించే లూప్
    for (const auto& pkt : packetStream) {
        ++inspectedPackets;

        // 1. continue ఉపయోగం: పోర్ట్ 80 హెల్త్‌చెక్ పింగ్ ప్యాకెట్లను తనిఖీ లేకుండా వైట్‌లిస్ట్ చేయండి
        if (pkt.threatScore == 0 && pkt.destPort == 80) {
            std::cout << std::left << std::setw(10) << pkt.packetId 
                      << std::setw(18) << pkt.sourceIp 
                      << std::setw(8)  << pkt.destPort 
                      << std::setw(14) << pkt.threatScore 
                      << "⚪ [వైట్‌లిస్ట్ స్కిప్]: ఇంటర్నల్ హెల్త్‌చెక్ ప్యాకెట్.\n";
            ++passedPackets;
            continue; // కరెంట్ ఇటరేషన్‌ను స్కిప్ చేసి తర్వాతి ప్యాకెట్‌కు వెళ్ళండి!
        }

        // 2. break ఉపయోగం: రిస్క్ స్కోర్ 90 దాటితే సిస్టమ్ పై క్రిటికల్ దాడి జరుగుతోందని గుర్తించి ఎమర్జెన్సీ లాక్‌డౌన్ చేయండి!
        if (pkt.threatScore >= 90) {
            std::cout << std::left << std::setw(10) << pkt.packetId 
                      << std::setw(18) << pkt.sourceIp 
                      << std::setw(8)  << pkt.destPort 
                      << std::setw(14) << pkt.threatScore 
                      << "🚨 [క్రిటికల్ అటాక్]: మాల్వేర్ గుర్తించబడింది! పేలోడ్: " << pkt.payload << "\n";
            emergencyLockdown = true;
            ++droppedPackets;
            std::cout << "\n🛑 [EMERGENCY SYSTEM LOCKDOWN]: నెట్‌వర్క్ కనెక్షన్ తక్షణమే తెంచబడింది!\n";
            break; // తక్షణమే లూప్ నుండి బ్రేక్ అయి బయటకు వచ్చేయండి!
        }

        // 3. సాధారణ త్రెట్ డ్రాపింగ్ (continue తో మిగిలిన కోడ్ బైపాస్)
        if (pkt.threatScore >= 70) {
            std::cout << std::left << std::setw(10) << pkt.packetId 
                      << std::setw(18) << pkt.sourceIp 
                      << std::setw(8)  << pkt.destPort 
                      << std::setw(14) << pkt.threatScore 
                      << "🔴 [ప్యాకెట్ డ్రాప్]: అధిక రిస్క్ ఉన్నందున బ్లాక్ చేయబడింది.\n";
            ++droppedPackets;
            continue;
        }

        // 4. క్లీన్ ప్యాకెట్లు సురక్షితంగా రౌట్ అవుతాయి
        std::cout << std::left << std::setw(10) << pkt.packetId 
                  << std::setw(18) << pkt.sourceIp 
                  << std::setw(8)  << pkt.destPort 
                  << std::setw(14) << pkt.threatScore 
                  << "🟢 [అనుమతించబడింది]: సురక్షితమైన ట్రాఫిక్.\n";
        ++passedPackets;
    }

    std::cout << "========================================================================================\n";
    std::cout << "పరిశీలించిన ప్యాకెట్లు  : " << inspectedPackets << " / " << packetStream.size() << "\n";
    std::cout << "ఆమోదించబడిన ప్యాకెట్లు : " << passedPackets << "\n";
    std::cout << "నిరోధించబడిన ప్యాకెట్లు : " << droppedPackets << "\n";
    std::cout << "ఎమర్జెన్సీ లాక్‌డౌన్ స్టేటస్ : " << (emergencyLockdown ? "🔒 ACTIVE" : "🟢 NORMAL") << "\n";
    std::cout << "========================================================================================\n";

    return 0;
}