ఆపరేటర్లు & ఎక్స్‌ప్రెషన్స్

1 ఆపరేటర్లు & ఎక్స్‌ప్రెషన్స్ అంటే ఏమిటి? (Operators & Operands)

కంప్యూటర్ ప్రాసెసర్ (ALU - Arithmetic Logic Unit) లో ఒక ఆపరేషన్ జరగడానికి మూడు ముఖ్య భాగాలు ఉంటాయి:

1. ఆపరేటర్ (Operator): కంప్యూటర్‌కు ఏ పని చేయాలో ఆదేశించే సంకేతం (ఉదాహరణకు: +, -, *, <<).
2. ఆపరాండ్ (Operand): ఆపరేటర్ ఏ విలువలపై పనిచేస్తుందో ఆ డేటా లేదా వేరియబుల్స్ (ఉదాహరణకు: a + b లో a మరియు b ఆపరాండ్లు).
3. ఎక్స్‌ప్రెషన్ (Expression): ఆపరేటర్లు మరియు ఆపరాండ్ల కలయిక ద్వారా ఒక ఫలిత విలువను ఉత్పత్తి చేసే పూర్తి స్టేట్‌మెంట్ (ఉదాహరణకు: total = (price * qty) - discount;).

ఆపరాండ్ల సంఖ్యను బట్టి C++ ఆపరేటర్లు 3 రకాలు:

• Unary Operators: కేవలం ఒకే ఆపరాండ్‌పై పనిచేస్తాయి (ఉదా: ++x, -x, !flag, sizeof(int)).
• Binary Operators: రెండు ఆపరాండ్ల మధ్య పనిచేస్తాయి (ఉదా: a + b, x > y, a && b).
• Ternary Operator: మూడు భాగాలతో పనిచేసే ఏకైక ఆపరేటర్ కండిషనల్ ఆపరేటర్ (condition ? true_val : false_val).

2 అరిథ్‌మెటిక్ ఆపరేటర్లు & Integer Division vs Floating Division

ప్రాథమిక గణిత గణనల కోసం C++ 5 ప్రధాన అరిథ్‌మెటిక్ ఆపరేటర్లను అందిస్తుంది:

3 ఇంక్రిమెంట్ & డిక్రిమెంట్: Prefix (++i) vs Postfix (i++) మైక్రోస్కోపిక్ మెమరీ తేడా

ఒక వేరియబుల్ విలువను 1 పెంచడానికి ++ మరియు 1 తగ్గించడానికి -- వాడతాము. అయితే వీటిని వేరియబుల్ ముందు రాస్తే Prefix అంటారు, వెనుక రాస్తే Postfix అంటారు.

#include <iostream>

int main() {
    int x = 5;
    int y = 5;

    // 1. Prefix: ముందు 1 పెరుగుతుంది (x=6), ఆపై a లోకి 6 వెళ్తుంది
    int a = ++x;

    // 2. Postfix: ముందు పాత విలువ (5) b లోకి వెళ్తుంది, ఆపై y 6 అవుతుంది
    int b = y++;

    std::cout << "Prefix  -> x: " << x << " | a: " << a << " (రెండు 6 అయ్యాయి)\n";
    std::cout << "Postfix -> y: " << y << " | b: " << b << " (b పాత విలువ 5 తీసుకుంది)\n";

    return 0;
}

4 అసైన్‌మెంట్ & కాంపౌండ్ అసైన్‌మెంట్ ఆపరేటర్లు

ఒక వేరియబుల్‌కు విలువను కేటాయించడానికి = (Simple Assignment) వాడతాము. అయితే కోడ్‌ను కుదించడానికి మరియు CPU వేగాన్ని పెంచడానికి C++ Compound Assignment Operators ను అందిస్తుంది:

• x += 5; అంటే x = x + 5; కు సమానం.
• x -= 3; అంటే x = x - 3; కు సమానం.
• x *= 2; అంటే x = x * 2; కు సమానం.
• x /= 4; అంటే x = x / 4; కు సమానం.
• x %= 2; అంటే x = x % 2; కు సమానం.

గమనిక: కాంపౌండ్ ఆపరేటర్లలో ఎడమవైపు వేరియబుల్ మెమరీ అడ్రస్ కేవలం ఒకే ఒక్కసారి మాత్రమే ఎవాల్యుయేట్ అవుతుంది, కాబట్టి ఇది చాలా వేగవంతమైనది.

5 రిలేషనల్ & కంపారిజన్ ఆపరేటర్లు

రెండు విలువల మధ్య సంబంధాన్ని పోల్చడానికి రిలేషనల్ ఆపరేటర్లను ఉపయోగిస్తాము. ఇవి ఎల్లప్పుడూ బూలియన్ ఫలితాన్ని (true లేదా false) ఇస్తాయి:

• == (Equal to): రెండు విలువలు సమానమా? (ఉదా: 5 == 5 yields true). ⚠️ గమనిక: సింగిల్ = అసైన్‌మెంట్, డబుల్ == కంపారిజన్!
• != (Not Equal to): రెండు విలువలు అసమానమా? (ఉదా: 5 != 3 yields true).
• > (Greater than), < (Less than): పెద్దదా లేదా చిన్నదా?
• >=, <= (Greater than or Equal to / Less than or Equal to).

6 C++20 Three-Way Comparison: స్పేస్‌షిప్ ఆపరేటర్ (<=>)

Modern C++20 లో ప్రవేశపెట్టబడిన అత్యంత విప్లవాత్మకమైన ఆపరేటర్ Three-Way Comparison Operator (<=>). దీని ఆకారం ఒక అంతరిక్ష నౌకలా ఉండటం వల్ల దీనిని ముద్దుగా "The Spaceship Operator" అంటారు!

గతంలో రెండు ఆబ్జెక్టులను పోల్చడానికి మనం 6 వేర్వేరు ఆపరేటర్లను (==, !=, <, >, <=, >=) ఓవర్‌లోడ్ చేయాల్సి వచ్చేది. కానీ C++20 లో కేవలం ఒక్క <=> రాస్తే చాలు, కంపైలర్ మిగిలిన 6 ఆపరేటర్లను ఆటోమేటిక్‌గా సిద్ధం చేస్తుంది!

#include <iostream>
#include <compare> // std::strong_ordering కోసం

int main() {
    int a = 10;
    int b = 20;

    auto result = (a <=> b);

    if (result < 0) {
        std::cout << "a అనేది b కంటే చిన్నది (a < b)\n";
    } else if (result > 0) {
        std::cout << "a అనేది b కంటే పెద్దది (a > b)\n";
    } else {
        std::cout << "రెండూ సమానం (a == b)\n";
    }

    return 0;
}

7 లాజికల్ ఆపరేటర్లు & షార్ట్-సర్క్యూట్ ఎవాల్యుయేషన్ (Short-Circuit)

ఒకటి కంటే ఎక్కువ కండిషన్లను కలపడానికి లాజికల్ ఆపరేటర్లు ఉపయోగపడతాయి:

• && (Logical AND): అన్ని కండిషన్లు true అయితేనే మొత్తం ఫలితం true.
• || (Logical OR): కనీసం ఒక్క కండిషన్ true అయినా మొత్తం ఫలితం true.
• ! (Logical NOT): ఫలితాన్ని తలక్రిందులు చేస్తుంది (true ని false గా, false ని true గా).

8 బిట్‌వైజ్ ఆపరేటర్లు: బైనరీ లెవల్ డేటా మానిప్యులేషన్ & బిట్ మాస్కింగ్

ఆటోమోటివ్, ఎంబెడెడ్ సిస్టమ్స్ మరియు గేమ్ ఇంజిన్లలో ప్రతి ఒక్క బిట్ విలువైనది. C++ హార్డ్‌వేర్ బిట్స్‌ను నేరుగా మార్చడానికి 6 బిట్‌వైజ్ ఆపరేటర్లను అందిస్తుంది:

• & (Bitwise AND): రెండు బిట్లు 1 అయితేనే 1.
• | (Bitwise OR): కనీసం ఒక బిట్ 1 అయినా 1.
• ^ (Bitwise XOR): రెండు బిట్లు వేర్వేరుగా ఉంటేనే 1 (1^0=1, 1^1=0). క్రిప్టోగ్రఫీలో విస్తృతంగా వాడతారు.
• ~ (Bitwise NOT / One's Complement): బిట్లను తిరగేస్తుంది (0 ని 1 గా, 1 ని 0 గా).
• << (Left Shift): బిట్లను ఎడమవైపు జరుపుతుంది. x << 1 అంటే x * 2 (రెట్టింపు వేగవంతమైన గుణకారం!).
• >> (Right Shift): బిట్లను కుడివైపు జరుపుతుంది. x >> 1 అంటే x / 2.

#include <iostream>
#include <bitset> // 8-బిట్ బైనరీ రిప్రజెంటేషన్ కోసం

int main() {
    unsigned char a = 5;  // బైనరీ: 00000101
    unsigned char b = 3;  // బైనరీ: 00000011

    std::cout << "a (5)  : " << std::bitset<8>(a) << '\n';
    std::cout << "b (3)  : " << std::bitset<8>(b) << '\n';
    std::cout << "a & b  : " << std::bitset<8>(a & b) << " (AND: 1)\n";
    std::cout << "a | b  : " << std::bitset<8>(a | b) << " (OR: 7)\n";
    std::cout << "a ^ b  : " << std::bitset<8>(a ^ b) << " (XOR: 6)\n";
    std::cout << "a << 1 : " << (a << 1) << " (Left Shift: 5 * 2 = 10)\n";

    return 0;
}

9 టెర్నరీ కండిషనల్ ఆపరేటర్ (? :)

చిన్న చిన్న if-else నిబంధనలను ఒకే ఒక్క లైన్‌లో అందంగా రాయడానికి Ternary Operator (? :) ఉపయోగపడుతుంది:

#include <iostream>
#include <string>

int main() {
    int score = 85;
    
    // టెర్నరీ ఆపరేటర్ ద్వారా ఒకే లైన్‌లో తీర్పు
    std::string grade = (score >= 90) ? "A+ (Excellent)" :
                        (score >= 75) ? "A (Very Good)" :
                        (score >= 50) ? "B (Good)" : "C (Needs Improvement)";

    std::cout << "విద్యార్థి స్కోర్: " << score << " => గ్రేడ్: " << grade << "\\n";

    // నేరుగా std::cout లోపల వాడే విధానం
    std::cout << "ఫలితం: " << ((score >= 50) ? "పాస్ (Passed!)" : "ఫెయిల్ (Failed)") << "\\n";
    return 0;
}

C++ లో టెర్నరీ ఆపరేటర్ ఒక ఎక్స్‌ప్రెషన్ కాబట్టి దీనిని నేరుగా std::cout లోపలే లేదా const వేరియబుల్స్ ప్రారంభంలో వాడవచ్చు!

10 ఆపరేటర్ ప్రిసిడెన్స్ & అసోసియేటివిటీ (Precedence & Associativity)

ఒక సంక్లిష్టమైన ఎక్స్‌ప్రెషన్‌లో అనేక ఆపరేటర్లు ఉన్నప్పుడు (ఉదా: x = 5 + 3 * 2;), కంపైలర్ ఏ పనిని ముందు చేయాలి? దీనిని నిర్ణయించే నియమాలనే Operator Precedence (ప్రాధాన్యత) అంటారు.

గణితంలో BODMAS లాగానే, C++ లో గుణకారం (*) మరియు భాగహారానికి (/), కూడిక (+) కంటే ఎక్కువ ప్రాధాన్యత ఉంటుంది. అందుకే 5 + 3 * 2 లో ముందుగా 3 * 2 = 6 జరిగి, ఆపై 5 + 6 = 11 అవుతుంది.

11 టైప్ ప్రమోషన్ & static_cast<T>()

వేర్వేరు డేటా టైపుల మధ్య ఆపరేషన్లు జరిగినప్పుడు, సమాచారం కోల్పోకుండా ఉండటానికి C++ చిన్న డేటా టైప్‌ను స్వయంచాలకంగా పెద్ద డేటా టైప్‌గా మారుస్తుంది. దీనిని Integral Promotion / Usual Arithmetic Conversions అంటారు.

• int + double కలిపితే ఫలితం double అవుతుంది.
• short + short కలిపితే CPU రిజిస్టర్లలో వేగంగా జరగడానికి కంపైలర్ రెండింటినీ int గా ప్రమోట్ చేస్తుంది.

కానీ బలవంతంగా టైప్ మార్చాల్సి వచ్చినప్పుడు ఎప్పుడూ పాత C-Style కాస్టింగ్ వాడకుండా Modern static_cast<T>() మాత్రమే వాడాలి.

12 సాధారణ బిగినర్ తప్పులు, Undefined Behavior & డివిజన్ బై జీరో

13 రియల్-వరల్డ్ ప్రాక్టీస్ ప్రాజెక్ట్: "Vehicle Sensor Telemetry & Bitmask Engine"

టెస్లా లేదా టాటా ఈవీ లాంటి మోడరన్ ఎలక్ట్రిక్ కార్లలో వాహన సెన్సార్ డేటా (ఇంజిన్ ఆన్, డోర్ లాక్, సీట్‌బెల్ట్, ఎయిర్‌బ్యాగ్) నెట్‌వర్క్ బ్యాండ్‌విడ్త్ ఆదా చేయడానికి సింగిల్ బైట్ లోని బిట్స్‌గా ప్రసారం చేయబడుతుంది.

ఈ మొదటి ఫేజ్ గ్రాండ్ ఫినాలేలో — మనం నేర్చుకున్న అరిథ్‌మెటిక్, రిలేషనల్, టెర్నరీ, మరియు బిట్‌వైజ్ మాస్కింగ్ అన్నింటినీ ఉపయోగించి ఒక పూర్తి స్థాయి "High-Performance Vehicle Telemetry Engine" ను నిర్మిద్దాం:

#include <iostream>
#include <string>
#include <iomanip>
#include <bitset>

// సెన్సార్ బిట్ మాస్క్‌లు (Bit Flags)
constexpr unsigned char ENGINE_ON      = 1 << 0; // Bit 0 (00000001) - 1
constexpr unsigned char DOORS_LOCKED   = 1 << 1; // Bit 1 (00000010) - 2
constexpr unsigned char SEATBELT_ON    = 1 << 2; // Bit 2 (00000100) - 4
constexpr unsigned char HANDBRAKE_PULL = 1 << 3; // Bit 3 (00001000) - 8

int main() {
    std::string vehicleModel = "TATA NEXON EV MAX (2026 Edition)";
    double currentSpeedKmph = 84.50;
    double batteryLevelPercent = 76.25;
    int odometerKm = 14520;

    // సింగిల్ బైట్ లో 4 సెన్సార్ల స్టేటస్ నిల్వ చేయడం (Bitwise OR |)
    unsigned char carStatus = 0;
    carStatus |= ENGINE_ON;       // ఇంజిన్ స్టార్ట్ అయింది
    carStatus |= DOORS_LOCKED;    // డోర్స్ లాక్ అయ్యాయి
    carStatus |= SEATBELT_ON;     // సీట్‌బెల్ట్ ధరించారు
    // హ్యాండ్‌బ్రేక్ రిలీజ్ చేయబడింది (కాబట్టి Bit 3 ఆఫ్ లో ఉంటుంది)

    // బిట్‌వైజ్ చెకింగ్ (Bitwise AND &)
    bool isEngineRunning = (carStatus & ENGINE_ON) != 0;
    bool isDoorsSecure   = (carStatus & DOORS_LOCKED) != 0;
    bool isSeatbeltBuckled = (carStatus & SEATBELT_ON) != 0;
    bool isHandbrakeEngaged = (carStatus & HANDBRAKE_PULL) != 0;

    // సేఫ్టీ ఎవాల్యుయేషన్ (Logical && + Ternary ? :)
    bool isDriveSafe = isEngineRunning && isDoorsSecure && isSeatbeltBuckled && !isHandbrakeEngaged;
    std::string safetyAlert = isDriveSafe ? "✅ అన్ని సేఫ్టీ ప్రమాణాలు సరిగ్గా ఉన్నాయి (SAFE TO CRUISE)" 
                                          : "⚠️ ప్రమాదం! సీట్‌బెల్ట్ లేదా డోర్స్ సరిచూసుకోండి (SAFETY WARNING!)";

    // అందమైన వెహికల్ టెలిమెట్రీ డ్యాష్‌బోర్డ్
    std::cout << std::fixed << std::setprecision(2);
    std::cout << "================================================================\n";
    std::cout << "          🚗 VEHICLE TELEMETRY & SENSOR DIAGNOSTICS ENGINE      \n";
    std::cout << "================================================================\n";
    std::cout << "వాహనం మోడల్     : " << vehicleModel << '\n';
    std::cout << "ప్రస్తుత వేగం   : " << currentSpeedKmph << " km/h\n";
    std::cout << "బ్యాటరీ స్థాయి  : " << batteryLevelPercent << " %\n";
    std::cout << "ఓడోమీటర్ రీడింగ్: " << odometerKm << " km\n";
    std::cout << "----------------------------------------------------------------\n";
    std::cout << "సెన్సార్ రా బైట్ (Raw Byte): " << std::bitset<8>(carStatus) << " (Hex: 0x" 
              << std::hex << static_cast<int>(carStatus) << std::dec << ")\n";
    std::cout << "----------------------------------------------------------------\n";
    std::cout << "ఇంజిన్ స్థితి     : " << (isEngineRunning ? "ON (నడుస్తోంది)" : "OFF") << '\n';
    std::cout << "డోర్ల భద్రత       : " << (isDoorsSecure ? "LOCKED (సురక్షితం)" : "UNLOCKED (తెరిచి ఉంది)") << '\n';
    std::cout << "సీట్‌బెల్ట్ స్థితి  : " << (isSeatbeltBuckled ? "BUCKLED (ధరించారు)" : "UNBUCKLED") << '\n';
    std::cout << "హ్యాండ్‌బ్రేక్ స్థితి: " << (isHandbrakeEngaged ? "ENGAGED" : "RELEASED (రిలీజ్ అయింది)") << '\n';
    std::cout << "================================================================\n";
    std::cout << "సిస్టమ్ డయాగ్నోస్టిక్స్ ఫలితం:\n" << safetyAlert << '\n';
    std::cout << "================================================================\n";

    return 0;
}

❓ ఇంటర్వ్యూ & పరీక్షల క్విజ్ (Knowledge Check)