వేరియబుల్స్, డేటా టైప్స్, కాన్‌స్టాంట్స్ & మెమరీ మోడల్

• RAM మెమరీ ఆర్కిటెక్చర్: బిట్స్ (Bits), బైట్లు (Bytes), మరియు హెక్సాడెసిమల్ మెమరీ అడ్రస్‌లు.
• వేరియబుల్స్ అనాటమీ: డిక్లరేషన్, ఇనిషియలైజేషన్, మరియు సి-స్టాండర్డ్ ఐడెంటిఫైయర్ నియమాలు.
• ప్రాథమిక డేటా టైప్స్: int, char, float, double — మెమరీ వినియోగం.
• 32-bit vs 64-bit సిస్టమ్స్: డేటా టైప్స్ పరిమాణాల్లో వ్యత్యాసాలు (ILP32 vs LP64 మోడల్స్).
• sizeof ఆపరేటర్: రన్‌టైమ్‌లో వేరియబుల్ లేదా డేటా టైప్ సైజును బైట్లలో కొలిచే ఏకైక కంపైలర్ సాధనం.
• సైన్డ్ vs అన్‌సైన్డ్ (Signed vs Unsigned): 2's Complement మెకానిక్స్, పాజిటివ్/నెగెటివ్ నంబర్ల బైనరీ రిప్రజెంటేషన్.
• ఇంటిజర్ ఓవర్‌ఫ్లో (Integer Overflow Trap): పరిమితి దాటితే ఏం జరుగుతుంది? రౌండ్-ట్రిప్ బగ్స్.
• టైప్ మోడిఫైయర్లు: short, long, long long, unsigned.
• కాన్‌స్టాంట్స్: రీడ్-ఓన్లీ వేరియబుల్స్ కోసం const కీవర్డ్ వర్సెస్ #define మ్యాక్రోలు.
• ASCII టేబుల్ రహస్యాలు: కంప్యూటర్‌కు అక్షరాలు తెలియవు; అన్నీ నంబర్లే! ('A' == 65).
• బిగినర్స్ చేసే ఘోరమైన తప్పులు: గార్బేజ్ విలువలు, ఫ్లోట్ ప్రెసిషన్ లాస్.
• ఇంటరాక్టివ్ క్విజ్: 5 లోతైన ఆలోచింపజేసే ప్రశ్నలు & వివరణలు.

C ప్రోగ్రామర్‌గా మారడానికి కంప్యూటర్ మెమరీ (RAM) ఎలా పనిచేస్తుందో స్పష్టమైన ఊహాచిత్రం ఉండాలి. కంప్యూటర్ చిప్‌లోని ట్రాన్సిస్టర్లు కేవలం ఆన్ (1) లేదా ఆఫ్ (0) స్టేట్‌లను మాత్రమే గ్రహించగలవు. ఈ ప్రాథమిక యూనిట్‌ను బిట్ (Bit - Binary Digit) అంటారు.

ప్రతి బైట్‌కు మెమరీలో ఒక ప్రత్యేకమైన సంఖ్య ఉంటుంది — దానినే మెమరీ అడ్రస్ (Memory Address) అంటారు. దీనిని సాధారణంగా హెక్సాడెసిమల్ రూపంలో (ఉదాహరణకు: 0x7ffee4b2) సూచిస్తారు. మనం C లో ఒక వేరియబుల్ క్రియేట్ చేసినప్పుడు, ఆపరేటింగ్ సిస్టమ్ RAM లోని ఒక నిర్దిష్ట అడ్రస్ వద్ద ఆ వేరియబుల్ సైజుకు సరిపడా బైట్లను రిజర్వ్ చేస్తుంది.

వేరియబుల్ (Variable): కంప్యూటర్ మెమరీ లొకేషన్‌కు మనం ఇచ్చే అర్థవంతమైన పేరు. ఆ లొకేషన్‌లో ఉన్న విలువ ప్రోగ్రామ్ రన్ అవుతున్న సమయంలో మారవచ్చు (Vary కావచ్చు) కాబట్టి దీనికి "వేరియబుల్" అని పేరు వచ్చింది.

డిక్లరేషన్ వర్సెస్ ఇనిషియలైజేషన్:

C ఐడెంటిఫైయర్ నియమాలు (Variable Naming Rules):

• వేరియబుల్ పేర్లు ఆంగ్ల అక్షరాలు (a-z, A-Z), అంకెలు (0-9), లేదా అండర్‌స్కోర్ (_) తో మాత్రమే ఉండాలి.
• మొదటి అక్షరం తప్పనిసరిగా అక్షరం లేదా అండర్‌స్కోర్ తో మాత్రమే ప్రారంభం కావాలి; అంకెతో మొదలుకాకూడదు (ఉదా: 1stRank తప్పు; rank1 సరైనది).
• ఖాళీలు (Spaces) లేదా ప్రత్యేక గుర్తులు ($, @, %, #) పూర్తిగా నిషేధం.
• C లాంగ్వేజ్‌లోని 32 రిజర్వ్‌డ్ కీవర్డ్లు (ఉదా: int, float, return, while) వేరియబుల్ పేర్లుగా వాడకూడదు.
• C కేస్-సెన్సిటివ్ కాబట్టి total, Total, మరియు TOTAL మూడు వేర్వేరు వేరియబుల్స్!

C లాంగ్వేజ్‌లో డేటాను భద్రపరచడానికి 4 ప్రాథమిక డేటా టైప్స్ ఉన్నాయి. ప్రతి డేటా టైప్‌కు కంప్యూటర్ మెమరీలో నిర్దిష్ట పరిమాణం మరియు నిర్దిష్ట పరిధి (Range) ఉంటుంది:

#include <stdio.h>

int main(void) {
    // 1. క్యారెక్టర్ వేరియబుల్ (సింగిల్ కోట్స్)
    char grade = 'A';
    
    // 2. పూర్ణాంక వేరియబుల్
    int studentId = 101;
    
    // 3. ఫ్లోటింగ్ పాయింట్ వేరియబుల్ (చివర f పెట్టడం మంచిది)
    float fee = 45000.50f;
    
    // 4. డబుల్ వేరియబుల్ (అధిక కచ్చితత్వం)
    double pi = 3.141592653589793;

    printf("విద్యార్థి ID: %d\n", studentId);
    printf("గ్రేడ్: %c\n", grade);
    printf("ఫీజు: ₹%.2f\n", fee); // %.2f అంటే దశాంశం తర్వాత 2 అంకెలు
    printf("పై (PI) విలువ: %.10lf\n", pi);

    return 0;
}

చాలామంది బిగినర్స్ "int ఎల్లప్పుడూ 4 బైట్లేనా? లేదా 2 బైట్లా?" అని గందరగోళానికి గురవుతారు. దీనికి సమాధానం: C ప్రమాణాలు డేటా టైప్స్ యొక్క కచ్చితమైన సైజును ఖరారు చేయలేదు; కేవలం కనీస పరిమితులను మాత్రమే సూచించాయి!

• C స్టాండర్డ్ నియమం: sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long) <= sizeof(long long).
• 16-bit Turbo C++ లో int కేవలం 2 బైట్లు మాత్రమే ఉండేది (పరిధి: -32,768 నుండి 32,767).
• ఆధునిక 32-bit మరియు 64-bit ప్రాసెసర్లలో (x86_64 GCC, Clang) int ఎల్లప్పుడూ 4 బైట్లు (32 bits) ఉంటుంది.
• Linux 64-bit (LP64 మోడల్) లో long 8 బైట్లు ఉంటుంది, కానీ Windows 64-bit (LLP64 మోడల్) లో long కేవలం 4 బైట్లు మాత్రమే ఉంటుంది! అందుకే ప్లాట్‌ఫామ్-ఇండిపెండెంట్ కోడ్ కోసం ఆధునిక C లో <stdint.h> ఉపయోగిస్తాం.

మీ కంప్యూటర్‌లో ఏ డేటా టైప్ ఎన్ని బైట్లు ఆక్రమిస్తుందో ఊహించాల్సిన పనిలేదు; C మనకు sizeof అనే ఇన్-బిల్ట్ కంపైల్-టైమ్ ఆపరేటర్‌ను అందించింది. ఇది ఒక ఫంక్షన్ కాదు, ఇది ఒక ఆపరేటర్ (Keyword Operator). దీని రిటర్న్ టైప్ size_t (అన్‌సైన్డ్ పూర్ణాంకం), కాబట్టి దీనిని ప్రింట్ చేయడానికి %zu లేదా %lu ఉపయోగిస్తాం:

#include <stdio.h>

int main(void) {
    printf("=== మీ మెషీన్‌లో డేటా టైప్స్ పరిమాణాలు (Bytes) ===\n");
    printf("char సైజు       : %zu Byte\n", sizeof(char));
    printf("short సైజు      : %zu Bytes\n", sizeof(short));
    printf("int సైజు        : %zu Bytes\n", sizeof(int));
    printf("long సైజు       : %zu Bytes\n", sizeof(long));
    printf("long long సైజు  : %zu Bytes\n", sizeof(long long));
    printf("float సైజు      : %zu Bytes\n", sizeof(float));
    printf("double సైజు     : %zu Bytes\n", sizeof(double));
    printf("long double సైజు: %zu Bytes\n", sizeof(long double));

    // వేరియబుల్ సైజును కూడా కొలవవచ్చు
    double salary = 75000.85;
    printf("salary వేరియబుల్ ఆక్రమించిన మెమరీ: %zu Bytes\n", sizeof(salary));

    return 0;
}

సాధారణంగా ఒక డేటా టైప్‌కు ముందు ఏమీ రాయకపోతే అది డీఫాల్ట్‌గా signed గా పరిగణించబడుతుంది (అంటే పాజిటివ్ మరియు నెగెటివ్ సంఖ్యలు రెండూ పట్టవచ్చు). కానీ కొన్ని సందర్భాలలో (ఉదా: వయస్సు, రోల్ నంబర్, మెమరీ సైజు, అరే సైజు) నెగెటివ్ విలువలు ఎప్పటికీ రావు. అప్పుడు unsigned కీవర్డ్ వాడటం వల్ల పాజిటివ్ రేంజ్ రెట్టింపు అవుతుంది!

⚠️ ఇంటిజర్ ఓవర్‌ఫ్లో రహస్యం (Integer Overflow Trap):

ఒక గడియారంలో ముల్లు 12 దాటితే మళ్ళీ 1 కి ఎలా వస్తుందో — కంప్యూటర్ మెమరీలో కూడా ఒక వేరియబుల్ గరిష్ట పరిమితిని దాటితే (Overflow అయితే) అది చక్రంలా తిరిగి కనిష్ట విలువకు వెళ్ళిపోతుంది! దీనిని Modulo Arithmetic (2's Complement Overflow) అంటారు:

#include <stdio.h>

int main(void) {
    // 1. Signed Char గరిష్ట పరిమితి 127
    signed char num1 = 127;
    printf("ప్రస్తుత విలువ: %d\n", num1);
    
    // 127 కి +1 కలిపితే ఏమవుతుంది? 128 అవ్వదు! -128 అవుతుంది!
    num1 = num1 + 1;
    printf("127 + 1 ఓవర్‌ఫ్లో తర్వాత విలువ: %d (Shocking!)\n\n", num1);

    // 2. Unsigned Char గరిష్ట పరిమితి 255
    unsigned char num2 = 255;
    printf("Unsigned ప్రస్తుత విలువ: %u\n", num2);
    
    // 255 కి +1 కలిపితే 0 అవుతుంది!
    num2 = num2 + 1;
    printf("255 + 1 ఓవర్‌ఫ్లో తర్వాత విలువ: %u\n", num2);

    return 0;
}

మన డేటా అవసరాన్ని బట్టి మెమరీని ఆదా చేయడానికి లేదా భారీ సంఖ్యలను భద్రపరచడానికి C లో 4 ప్రాథమిక మోడిఫైయర్లు (Modifiers) ఉన్నాయి:

• short int (లేదా కేవలం short): 2 బైట్లు. చిన్న సంఖ్యల కోసం (-32,768 నుండి 32,767). మెమరీ అత్యంత పరిమితంగా ఉండే మైక్రోకంట్రోలర్లలో వాడతారు.
• long int (లేదా కేవలం long): కనీసం 4 లేదా 8 బైట్లు. ఫార్మాట్ స్పెసిఫైయర్ %ld.
• long long int (లేదా long long): 8 బైట్లు (64 bits). ఇది ప్రపంచ జనాభా, దేశ బడ్జెట్, లేదా బిలియన్ల లావాదేవీలను భద్రపరచడానికి సరిపోతుంది (-9,223,372,036,854,775,808 నుండి +9,223,372,036,854,775,807 వరకు!). ఫార్మాట్ స్పెసిఫైయర్ %lld.
• unsigned long long: కేవలం పాజిటివ్ విలువలు (0 నుండి సుమారు 1.8 × 10¹⁹ వరకు). ఫార్మాట్ స్పెసిఫైయర్ %llu.

#include <stdio.h>

int main(void) {
    // ప్రపంచ జనాభా (సుమారు 800 కోట్లు) int లో పట్టదు; long long వాడాలి!
    long long worldPopulation = 8100000000LL; // LL ప్రత్యయం చేర్చాలి
    
    printf("ప్రపంచ జనాభా అంచనా: %lld\n", worldPopulation);
    printf("తీసుకున్న మెమరీ సైజు: %zu Bytes\n", sizeof(worldPopulation));

    return 0;
}

ప్రోగ్రామ్‌లో కొన్ని విలువలు ఎప్పటికీ మారకూడదు (ఉదాహరణకు: PI = 3.14159, MAX_USERS = 100, SPEED_OF_LIGHT = 299792458). C లో వీటిని స్థిరంగా (Constants గా) ఉంచడానికి రెండు మార్గాలు ఉన్నాయి:

కంప్యూటర్ హార్డ్‌వేర్‌కు అక్షరాలు, గుర్తులు ఏవీ అర్థం కావు. కంప్యూటర్ అంతర్గతంగా ప్రతి అక్షరాన్ని ఒక సంఖ్యగా (Integer Code) మాత్రమే నిల్వ చేస్తుంది. ఈ అంతర్జాతీయ ప్రమాణాన్ని ASCII (American Standard Code for Information Interchange) అంటారు.

C లో char అనేది వాస్తవానికి కేవలం 1 బైట్ పూర్ణాంకం (1-byte integer) మాత్రమే! మీరు 'A' అని రాసినప్పుడు కంపైలర్ మెమరీలో 65 అనే సంఖ్యను సేవ్ చేస్తుంది:

#include <stdio.h>

int main(void) {
    char ch = 'A';

    // %c తో ప్రింట్ చేస్తే అక్షరం 'A' వస్తుంది
    printf("క్యారెక్టర్‌గా : %c\n", ch);

    // %d తో ప్రింట్ చేస్తే దాని ASCII సంఖ్య 65 వస్తుంది!
    printf("ASCII సంఖ్యగా : %d\n", ch);

    // క్యారెక్టర్లపై గణితం చేయవచ్చు!
    char nextChar = ch + 1; // 65 + 1 = 66 ('B')
    printf("'A' + 1 = %c (ASCII: %d)\n", nextChar, nextChar);

    // చిన్న అక్షరం నుండి పెద్ద అక్షరంగా మార్చడం (Case Conversion Logic)
    char lower = 'g';
    char upper = lower - 32; // 'a'(97) - 32 = 'A'(65)
    printf("చిన్న అక్షరం: %c -> పెద్ద అక్షరం: %c\n", lower, upper);

    return 0;
}

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