వేరియబుల్స్, డేటా టైప్స్ & auto

1 వేరియబుల్ అంటే ఏమిటి? కంప్యూటర్ RAM మెమరీలో అసలు ఏం జరుగుతుంది?

ఒక వేరియబుల్ (Variable) అంటే సరళంగా చెప్పాలంటే "విలువను భద్రపరిచే ఒక మెమరీ పెట్టె (Named Memory Container)". కంప్యూటర్ యొక్క ప్రాథమిక మెమరీ అయిన RAM (Random Access Memory) అనేది బిలియన్ల కొద్దీ 1-బైట్ (8-bits) మెమరీ గదుల సమాహారం. ప్రతి గదికి ఒక ప్రత్యేకమైన హెక్సాడెసిమల్ చిరునామా (Hexadecimal Memory Address, ఉదాహరణకు 0x7ffee4b2a8) ఉంటుంది.

మనం ప్రోగ్రామ్‌లో అలాంటి సంక్లిష్టమైన మెమరీ అడ్రస్‌లను గుర్తుపెట్టుకోవడం అసాధ్యం. అందుకే మనం ఒక మెమరీ లొకేషన్‌కు ఇచ్చే మానవ-అనుకూలమైన పేరునే వేరియబుల్ అంటాము.

2 C++ ఫండమెంటల్ డేటా టైప్స్ వర్గీకరణ (Core Type System)

C++ అనేది Statically Typed లాంగ్వేజ్. అంటే ప్రతి వేరియబుల్ యొక్క డేటా టైప్ కంపైలేషన్ సమయంలోనే స్పష్టంగా తెలిసి ఉండాలి. ఒక వేరియబుల్‌కు ఒక టైప్ ఇచ్చిన తర్వాత దానిలోకి వేరే టైప్ డేటాను బలవంతంగా పెట్టలేము. C++ డేటా టైప్స్ ప్రధానంగా మూడు వర్గాలుగా విభజించబడ్డాయి:

3 పూర్ణాంకాలు (Integers): short, int, long, long long & Signed vs Unsigned

పూర్ణాంకాలు అంటే దశాంశాలు (Decimals) లేని సంఖ్యలు. వివిధ సైజుల సంఖ్యలను భద్రపరచడానికి C++ నాలుగు ప్రధాన పూర్ణాంక రకాలను అందిస్తుంది:

4 ఫ్లోటింగ్ పాయింట్ సంఖ్యలు: float, double, long double & IEEE-754

దశాంశ బిందువులు (డెసిమల్స్) ఉండే సైంటిఫిక్ గణనలు మరియు కరెన్సీ కాలిక్యులేషన్ల కోసం C++ మూడు రకాల ఫ్లోటింగ్-పాయింట్ రకాలను అందిస్తుంది:

• float (Single Precision - 4 Bytes): సుమారు 7 డెసిమల్ అంకెల కచ్చితత్వాన్ని (Precision) ఇస్తుంది. సంఖ్య చివర f అక్షరం పెట్టాలి (ఉదా: 3.14159f).
• double (Double Precision - 8 Bytes): సుమారు 15 నుండి 17 డెసిమల్ అంకెల అద్భుతమైన కచ్చితత్వాన్ని ఇస్తుంది. ఆధునిక CPU లలో ఇది డిఫాల్ట్ మరియు అత్యంత వేగవంతమైన ఛాయిస్!
• long double (Extended Precision - 8, 12, లేదా 16 Bytes): అంతరిక్ష శాస్త్రం మరియు క్వాంటం ఫిజిక్స్ పరిశోధనల్లో అత్యున్నత కచ్చితత్వం కోసం వాడతారు.

#include <iostream>
#include <iomanip> // std::setprecision కోసం

int main() {
    float fVal = 1.0f / 3.0f;
    double dVal = 1.0 / 3.0;

    std::cout << std::setprecision(18); // 18 స్థానాల వరకు ప్రింట్ చేయడం
    std::cout << "Float Precision (7 digits):   " << fVal << '\n';
    std::cout << "Double Precision (16 digits):  " << dVal << '\n';

    return 0;
}

5 అక్షరాలు & బూలియన్లు: char, bool, ASCII & Modern char8_t

టెక్స్ట్ మరియు బూలియన్ ట్రూత్ వాల్యూస్ కంప్యూటర్ మెమరీలో ఎలా భద్రపరచబడతాయి?

• char (1 Byte / 8-bits): సింగిల్ క్యారెక్టర్‌ను నిల్వ చేస్తుంది. అంతర్గతంగా ఇది ఒక చిన్న ఇంటిజర్ (ASCII కోడ్). ఉదాహరణకు char ch = 'A'; అని రాస్తే మెమరీలో 65 అనే బైనరీ విలువ సేవ్ అవుతుంది!
• bool (1 Byte): కేవలం true (1) లేదా false (0) లను మాత్రమే నిల్వ చేస్తుంది. వాస్తవానికి 1 బిట్ సరిపోయినప్పటికీ, CPU మెమరీ అడ్రసింగ్ సులభతరం కోసం 1 పూర్తి బైట్ కేటాయించబడుతుంది.
• char8_t (C++20), char16_t, wchar_t: ప్రపంచంలోని వివిధ భాషల యూనికోడ్ (UTF-8, UTF-16, తెలుగు ఫాంట్స్) ప్రాసెస్ చేయడానికి మోడరన్ C++ లో చేర్చబడ్డాయి.

6 sizeof ఆపరేటర్ & <limits> హెడర్ ఫైల్ (Memory & Ranges)

మీ కంప్యూటర్ ఆర్కిటెక్చర్‌లో ఏ డేటా టైప్ ఎంత స్థలాన్ని తీసుకుంటుందో తెలుసుకోవడానికి sizeof ఆపరేటర్ ఉపయోగపడుతుంది. అలాగే <limits> హెడర్ ద్వారా ఏ టైప్ గరిష్టంగా ఎంత సంఖ్యను నిల్వ చేయగలదో తెలుసుకోవచ్చు:

#include <iostream>
#include <limits>

int main() {
    std::cout << "--- C++ టైప్ మెమరీ సైజులు & పరిధులు ---\n";
    std::cout << "int సైజు: " << sizeof(int) << " Bytes | Min: " 
              << std::numeric_limits<int>::min() << " | Max: " 
              << std::numeric_limits<int>::max() << '\n';

    std::cout << "double సైజు: " << sizeof(double) << " Bytes | Max: " 
              << std::numeric_limits<double>::max() << '\n';

    std::cout << "char సైజు: " << sizeof(char) << " Byte\n";
    std::cout << "bool సైజు: " << sizeof(bool) << " Byte\n";

    return 0;
}

7 వేరియబుల్ ఇనిషియలైజేషన్: C-Style vs Modern C++11 Uniform Initialization ({})

C++ లో వేరియబుల్స్‌ను ప్రారంభించడానికి (Initialize) 3 మార్గాలు ఉన్నాయి:

1. int a = 10; (C-Style Copy Initialization)
2. int b(20); (Direct Constructor Initialization)
3. int c{30}; (Modern C++11 Uniform / Brace Initialization) — 🌟 ప్రొఫెషనల్ గోల్డ్ స్టాండర్డ్!

8 auto కీవర్డ్: Modern C++ టైప్ ఇన్ఫరెన్స్ (Type Inference)

C++11 లో ప్రవేశపెట్టబడిన అత్యంత శక్తివంతమైన ఆధునిక ఫీచర్ auto కీవర్డ్. వేరియబుల్‌కు మీరు కేటాయించే ప్రారంభ విలువను బట్టి కంపైలర్ స్వయంగా సరైన డేటా టైప్‌ను కంపైల్ సమయంలోనే నిర్ణయిస్తుంది (Automatic Type Deduction).

#include <iostream>
#include <typeinfo>

int main() {
    auto age = 25;           // కంపైలర్ ఆటోమేటిక్‌గా 'int' గా గుర్తిస్తుంది
    auto price = 99.50;      // కంపైలర్ 'double' గా గుర్తిస్తుంది
    auto currency = '₹';     // 'char'
    auto isOnline = true;    // 'bool'

    std::cout << "Age: " << age << " (Bytes: " << sizeof(age) << ")\n";
    std::cout << "Price: " << price << " (Bytes: " << sizeof(price) << ")\n";

    return 0;
}

ముఖ్య గమనిక: auto వాడినప్పుడు పర్ఫార్మెన్స్ ఒక్క శాతం కూడా తగ్గదు! ఎందుకంటే టైప్ నిర్ణయించే పని కంపైలర్ చేస్తుంది, రన్‌టైమ్ కాదు.

9 const vs constexpr vs consteval: కంపైల్-టైమ్ కాన్స్టాంట్స్

ప్రోగ్రామ్‌లో మారకూడని విలువలను స్థిరంగా ఉంచడానికి (Constants) C++ లో మూడు స్థాయిల రక్షణ ఉంది:

10 వేరియబుల్ స్కోప్ & లైఫ్‌టైమ్ (Scope, Lifetime & Shadowing)

ఒక వేరియబుల్ ప్రోగ్రామ్‌లో ఎక్కడెక్కడ అందుబాటులో ఉంటుంది (Scope) మరియు ఎంతసేపు RAM మెమరీలో జీవించి ఉంటుంది (Lifetime)?

• Local Scope (బ్లాక్ స్కోప్): ఒక ఫంక్షన్ లేదా { ... } కర్లీ బ్రాకెట్ల లోపల డిక్లేర్ చేసిన వేరియబుల్స్ ఆ బ్లాక్ ముగియగానే మెమరీ నుండి ఆటోమేటిక్‌గా నశించిపోతాయి (Stack Memory Cleanup).
• Global Scope: అన్ని ఫంక్షన్ల కంటే పైన బయట డిక్లేర్ చేసిన వేరియబుల్స్ ప్రోగ్రామ్ ముగిసేవరకు జీవించి ఉంటాయి.
• Variable Shadowing: గ్లోబల్ వేరియబుల్ పేరుతోనే లోకల్ వేరియబుల్ సృష్టిస్తే, లోకల్ వేరియబుల్ గ్లోబల్ దాన్ని దాచిపెడుతుంది. గ్లోబల్ వేరియబుల్‌ను తిరిగి యాక్సెస్ చేయడానికి Scope Resolution Operator (::) వాడాలి.

#include <iostream>

int globalTaxRate = 18; // గ్లోబల్ వేరియబుల్

int main() {
    int globalTaxRate = 5; // లోకల్ వేరియబుల్ (Shadows the global one)

    std::cout << "లోకల్ టాక్స్ రేట్: " << globalTaxRate << "%\n";
    std::cout << "గ్లోబల్ టాక్స్ రేట్ (:: తో): " << ::globalTaxRate << "%\n";

    return 0;
}

11 టైప్ కాస్టింగ్ మెకానిక్స్: Implicit Coercion vs Modern static_cast

ఒక డేటా టైప్‌ను మరొక డేటా టైప్‌గా మార్చడాన్ని Type Casting అంటారు. C++ లో పాత C-Style కాస్టింగ్ ((int)3.14) వాడటం నిషేధం. ఎందుకంటే అది టైప్ సేఫ్టీని విస్మరించి ప్రమాదకరమైన మెమరీ బగ్స్ తెస్తుంది. ఆధునిక C++ లో స్పష్టమైన static_cast<T>() వాడాలి!

#include <iostream>

int main() {
    int totalMarks = 475;
    int maxMarks = 500;

    // ❌ ప్రమాదం: రెండు పూర్ణాంకాల భాగహారం ఎల్లప్పుడూ పూర్ణాంకమే (0 అవుతుంది!)
    double wrongPercentage = totalMarks / maxMarks * 100;

    // ✅ సరైన ఆధునిక C++ పరిష్కారం: static_cast తో కన్వర్ట్ చేయడం
    double correctPercentage = static_cast<double>(totalMarks) / maxMarks * 100.0;

    std::cout << "తప్పుడు పద్ధతి పర్సంటేజ్ : " << wrongPercentage << "%\n";
    std::cout << "static_cast తో కచ్చితమైన ఫలితం: " << correctPercentage << "%\n";

    return 0;
}

12 సాధారణ బిగినర్ తప్పులు, అన్‌ఇనిషియలైజ్డ్ గార్బేజ్ & Overflow Bugs

13 రియల్-వరల్డ్ ప్రాక్టీస్ ప్రాజెక్ట్: "Enterprise Employee Payroll Engine"

ఈ అధ్యాయంలో మనం నేర్చుకున్న auto, constexpr, sizeof, static_cast మరియు బ్రేస్ ఇనిషియలైజేషన్ అన్నింటినీ ఉపయోగించి ఒక నిజమైన "Enterprise Employee Payroll & Tax Architecture Engine" ను నిర్మిద్దాం:

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

int main() {
    // 1. కంపైల్-టైమ్ కాన్స్టాంట్స్ (constexpr)
    constexpr double PF_PERCENT{12.0};       // ప్రావిడెంట్ ఫండ్ 12%
    constexpr double PROFESSIONAL_TAX{200.0}; // ప్రొఫెషనల్ టాక్స్ ₹200
    constexpr double HEALTH_INSURANCE{1500.0};

    // 2. ఎంప్లాయ్ డేటా (Modern Brace Initialization & auto)
    const std::string empName{"శ్రీకాంత్ వర్మ (Srikanth Varma)"};
    const long long empId{9804218765LL}; // 64-bit integer
    double basicSalary{85000.00};
    double performanceBonus{12500.50};
    char performanceGrade{'A'};
    bool isEligibleForIncrement{true};

    // 3. శాలరీ కాలిక్యులేషన్స్
    auto grossSalary = basicSalary + performanceBonus;
    auto pfDeduction = grossSalary * (PF_PERCENT / 100.0);
    auto totalDeductions = pfDeduction + PROFESSIONAL_TAX + HEALTH_INSURANCE;
    auto netInHandSalary = grossSalary - totalDeductions;

    // 4. అందమైన పేస్లిప్ జనరేషన్
    std::cout << std::fixed << std::setprecision(2);
    std::cout << "=================================================\n";
    std::cout << "       🏢 OUR COMPILER ENTERPRISE PAYROLL        \n";
    std::cout << "=================================================\n";
    std::cout << "ఉద్యోగి పేరు       : " << empName << '\n';
    std::cout << "ఎంప్లాయ్ ఐడీ       : " << empId << " (64-bit Size: " << sizeof(empId) << "B)\n";
    std::cout << "పెర్ఫార్మెన్స్ గ్రేడ్: " << performanceGrade << '\n';
    std::cout << "ఇంక్రిమెంట్ అర్హత  : " << (isEligibleForIncrement ? "అవును (Eligible)" : "కాదు") << '\n';
    std::cout << "-------------------------------------------------\n";
    std::cout << "బేసిక్ శాలరీ       : ₹ " << basicSalary << '\n';
    std::cout << "పెర్ఫార్మెన్స్ బోనస్: ₹ " << performanceBonus << '\n';
    std::cout << "గ్రాస్ జీతం (Gross) : ₹ " << grossSalary << '\n';
    std::cout << "-------------------------------------------------\n";
    std::cout << "PF కటింగ్ (12%)    : -₹ " << pfDeduction << '\n';
    std::cout << "హెల్త్ ఇన్సూరెన్స్ : -₹ " << HEALTH_INSURANCE << '\n';
    std::cout << "ప్రొఫెషనల్ టాక్స్  : -₹ " << PROFESSIONAL_TAX << '\n';
    std::cout << "మొత్తం తగ్గింపులు  : -₹ " << totalDeductions << '\n';
    std::cout << "=================================================\n";
    std::cout << "నెట్ టేక్-హోమ్ శాలరీ: ₹ " << netInHandSalary << " /-\n";
    std::cout << "=================================================\n";

    return 0;
}

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