ఆపరేటర్లు, ఎక్స్‌ప్రెషన్స్ & ప్రిసిడెన్స్ నియమాలు

• ఆపరేటర్లు & ఎక్స్‌ప్రెషన్స్ పరిచయం: Operands, Operators, మరియు Expressions ఆర్కిటెక్చర్.
• అరిథ్‌మెటిక్ ఆపరేటర్లు: +, -, *, /, % (మాడ్యులో శేషం నియమాలు).
• Prefix (++i) vs Postfix (i++): తాత్కాలిక రిజిస్టర్ కాపీ వర్సెస్ తక్షణ ఇంక్రిమెంట్ మెమరీ మెకానిక్స్.
• రిలేషనల్ ఆపరేటర్లు: ==, !=, >, <, >=, <= (C లో బూలియన్ అంటే 1 మరియు 0).
• లాజికల్ ఆపరేటర్లు & షార్ట్-సర్క్యూట్: &&, ||, ! లలో కండిషన్ స్కిప్పింగ్ మెకానిజం.
• బిట్‌వైజ్ ఆపరేటర్లు: &, |, ^, ~, <<, >> తో హార్డ్‌వేర్ లెవల్ ఫాస్ట్ మల్టిప్లికేషన్.
• అసైన్‌మెంట్ ఆపరేటర్లు: కాంపౌండ్ అసైన్‌మెంట్ (+=, -=, *=, /=).
• కండిషనల్ టెర్నరీ ఆపరేటర్ (? :): వన్-లైన్ డెసిషన్ మేకింగ్ సింటాక్స్.
• ఆపరేటర్ ప్రిసిడెన్స్ & అసోసియేటివిటీ: BODMAS కంటే సంక్లిష్టమైన C ఆపరేటర్ ప్రాధాన్యతా టేబుల్.
• టైప్ కాస్టింగ్: ఇంప్లిసిట్ ప్రమోషన్ vs ఎక్స్‌ప్లిసిట్ టైప్ కాస్టింగ్ ((float)a / b).
• ఇంటరాక్టివ్ క్విజ్: 5 ట్రిక్కీ ప్రాక్టికల్ ప్రశ్నలు & విశ్లేషణ.

ఒక ప్రోగ్రామ్‌లో డేటాపై నిర్దిష్ట గణిత లేదా తార్కిక చర్యలను (Operations) చేయడానికి ఉపయోగించే చిహ్నాలను ఆపరేటర్లు (Operators) అంటారు. ఆపరేటర్ ఏ విలువలపై అయితే పనిచేస్తుందో ఆ విలువలను ఆపరాండ్లు (Operands) అంటారు:

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

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

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

జాబ్ ఇంటర్వ్యూలలో బిగినర్లను అత్యధికంగా గందరగోళానికి గురిచేసే టాపిక్ ఇంక్రిమెంట్ (++) మరియు డిక్రిమెంట్ (--) ఆపరేటర్లు:

#include <stdio.h>

int main(void) {
    int a = 5;
    int b = 5;

    // 1. Postfix: ముందు పాత విలువ 5 అసైన్ అవుతుంది, తర్వాత a = 6 అవుతుంది
    int res1 = a++; 
    printf("Postfix -> res1: %d, a: %d\n", res1, a); // res1: 5, a: 6

    // 2. Prefix: ముందు b = 6 అవుతుంది, తర్వాత ఆ 6 అసైన్ అవుతుంది
    int res2 = ++b; 
    printf("Prefix  -> res2: %d, b: %d\n", res2, b); // res2: 6, b: 6

    return 0;
}

రెండు విలువల మధ్య సంబంధాన్ని పోల్చడానికి రిలేషనల్ ఆపరేటర్లు వాడతాం. పైథాన్‌లో True, False అని ప్రత్యేక బూలియన్ పదాలు ఉంటాయి. కానీ ఒరిజినల్ C భాషలో బూలియన్ డేటా టైప్ లేదు!

అనేక కండిషన్లను ఒకదానితో ఒకటి కలిపి సంక్లిష్టమైన నిర్ణయాలు తీసుకోవడానికి 3 లాజికల్ ఆపరేటర్లు ఉన్నాయి:

• && (Logical AND): రెండు కండిషన్లూ నిజమైతేనే (True) ఫలితం 1 అవుతుంది.
• || (Logical OR): రెండింటిలో ఏ ఒక్క కండిషన్ నిజమైనా ఫలితం 1 అవుతుంది.
• ! (Logical NOT): సత్యాన్ని అసత్యంగా, అసత్యాన్ని సత్యంగా తలకిందులు చేస్తుంది.

⚡ షార్ట్-సర్క్యూట్ ఎవాల్యుయేషన్ (Short-Circuit Magic):

C కంపైలర్ సమయాన్ని ఆదా చేయడానికి చాలా తెలివైన టెక్నిక్‌ను ఉపయోగిస్తుంది:

• AND (&&) లో: మొదటి కండిషన్ ఫాల్స్ (0) అయితే — రెండో కండిషన్‌ను అసలు చూడను కూడా చూడదు! ఎందుకంటే ఒకటి ఫాల్స్ అయితే మొత్తం ఫాల్స్ అని తెలుసు.
• OR (||) లో: మొదటి కండిషన్ ట్రూ (1) అయితే — రెండో కండిషన్‌ను ఎగ్జిక్యూట్ చేయదు! ఎందుకంటే ఒకటి ట్రూ అయితే మొత్తం ట్రూ అని ఖరారైపోతుంది.

#include <stdio.h>

int main(void) {
    int a = 0;
    int b = 10;

    // a == 0 కాబట్టి మొదటి కండిషన్ ఫాల్స్! దాంతో ++b ఎగ్జిక్యూట్ అవ్వదు!
    if (a != 0 && ++b > 10) {
        printf("ఈ బ్లాక్ రన్ అవ్వదు\n");
    }

    printf("షార్ట్ సర్క్యూట్ వల్ల b విలువ పెరగలేదు: %d\n", b); // b విలువ ఇంకా 10 మాత్రమే!

    return 0;
}

కంప్యూటర్ మెమరీలోని ప్రతి బిట్‌ను (0 మరియు 1) నేరుగా నియంత్రించడానికి ఉపయోగించే అత్యంత శక్తివంతమైన ఆపరేటర్లు ఇవి. ఎంబెడెడ్ సిస్టమ్స్, డివైస్ డ్రైవర్లు, క్రిప్టోగ్రఫీ మరియు గేమింగ్ ఇంజిన్లలో వీటిని విరివిగా వాడతారు:

ఒక వేరియబుల్‌కు విలువను కేటాయించడానికి = వాడతాం. కోడ్‌ను క్లుప్తంగా, అందంగా రాయడానికి C లో కాంపౌండ్ అసైన్‌మెంట్ (Compound Assignment) ఆపరేటర్లు ఉన్నాయి:

• 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;

చిన్న చిన్న డెసిషన్ మేకింగ్ కోసం 4 లైన్ల if-else రాయకుండా — ఒకే ఒక్క లైన్‌లో షార్ట్‌కట్‌గా విలువను నిర్ణయించే అద్భుతమైన ఆపరేటర్ టెర్నరీ ఆపరేటర్ (Ternary Operator):

#include <stdio.h>

int main(void) {
    int marks = 75;

    // టెర్నరీ ఆపరేటర్‌తో ఫలితం నిర్ణయం
    char *result = (marks >= 40) ? "పాస్ అయ్యారు! 🎉" : "ఫెయిల్ అయ్యారు ❌";

    printf("పరీక్ష ఫలితం: %s\n", result);

    // రెండు సంఖ్యలలో ఏది పెద్దదో కనుగొనడం
    int x = 45, y = 80;
    int max = (x > y) ? x : y;
    printf("పెద్ద సంఖ్య: %d\n", max);

    return 0;
}

ఒక ఎక్స్‌ప్రెషన్‌లో అనేక ఆపరేటర్లు ఉన్నప్పుడు (ఉదా: x = 5 + 3 * 2;) — కంపైలర్ ఏ పనిని ముందు చేయాలి? పాఠశాలలో మనం నేర్చుకున్న BODMAS సూత్రం C లో సరిపోదు; C కి ప్రత్యేకమైన 15 స్థాయిల Precedence (ప్రాధాన్యత) మరియు Associativity (దిశ) నియమాలు ఉన్నాయి:

ఒక డేటా టైప్‌ను మరొక డేటా టైప్‌గా మార్చే ప్రక్రియనే టైప్ కాస్టింగ్ (Type Casting) అంటారు. ఇది రెండు రకాలుగా జరుగుతుంది:

1. ఇంప్లిసిట్ టైప్ కాస్టింగ్ (Implicit Type Promotion):

రెండు వేర్వేరు సైజు గల డేటా టైప్స్ కలిసినప్పుడు — కంపైలర్ స్వయంచాలకంగా చిన్న డేటా టైప్‌ను పెద్ద డేటా టైప్‌గా ప్రమోట్ చేస్తుంది (ఉదాహరణకు int + float కలిపితే ఫలితం ఆటోమేటిక్‌గా float అవుతుంది).

2. ఎక్స్‌ప్లిసిట్ టైప్ కాస్టింగ్ (Explicit Casting):

ప్రోగ్రామర్ ఉద్దేశపూర్వకంగా ఒక విలువ ముందు బ్రాకెట్లలో కావాల్సిన డేటా టైప్ రాసి బలవంతంగా మార్చడం:

#include <stdio.h>

int main(void) {
    int totalMarks = 485;
    int subjects = 6;

    // 1. కాస్టింగ్ లేకపోతే: 485 / 6 = 80.000000 మాత్రమే వస్తుంది!
    float wrongAvg = totalMarks / subjects;
    printf("తప్పుడు సగటు : %.2f\n", wrongAvg);

    // 2. ఎక్స్‌ప్లిసిట్ కాస్టింగ్: (float)totalMarks ద్వారా 80.833336 వస్తుంది!
    float correctAvg = (float)totalMarks / subjects;
    printf("సరైన సగటు   : %.2f\n", correctAvg);

    return 0;
}

ఈ నాల్గవ అధ్యాయంలో మీరు నేర్చుకున్న ఆపరేటర్ల సూక్ష్మ భావనలను పరీక్షించుకోవడానికి క్రింది ప్రశ్నలపై క్లిక్ చేయండి: