Scope and Storage Classes

Scope और storage — दो अलग सवाल

हर variable दो सवालों का जवाब देता है:

• Scope: code में *कहाँ* इस नाम का इस्तेमाल हो सकता है?
• Storage duration (lifetime): variable *कब* बनता है और कब नष्ट होता है?

Beginners अक्सर इन्हें मिला देते हैं। जैसे function के अंदर का static variable सिर्फ उसी function में *इस्तेमाल* हो सकता है (छोटा scope), पर पूरे program के चलने तक *मौजूद* रहता है (लंबा lifetime)। Storage class specifiers — static, extern, thread_local, mutable — lifetime और linkage तय करते हैं।

Scope के प्रकार

#include <iostream>
int total = 100;               // global

int main() {
    int total = 5;             // local, global को छिपा देता है
    {
        int bonus = 2;         // block scope
        std::cout << total + bonus << "\n";   // 7
    }
    // std::cout << bonus;     // error: यहाँ bonus scope में नहीं
    std::cout << ::total << "\n";             // 100 — :: से global
    return 0;
}

जब local नाम global को छिपा दे, तो scope resolution operator ::name से global तक पहुँचते हैं। ऐसे नाम छिपाना legal है पर उलझाने वाला — अलग नाम रखना बेहतर है।

Automatic storage (default)

बिना specifier वाले local variables की storage automatic होती है: execution declaration तक पहुँचने पर बनते हैं और block ख़त्म होने पर नष्ट हो जाते हैं। हर function call को नई copies मिलती हैं। बिना initialise किए automatic variables में garbage होता है, इसलिए हमेशा initialise करें।

static local variables

static local variable एक बार initialise होता है और calls के बीच अपनी value बनाए रखता है।

#include <iostream>

void markAttendance() {
    static int count = 0;      // एक बार बनता है, program ख़त्म होने तक रहता है
    int calls = 0;             // automatic: हर call में नया
    count++;
    calls++;
    std::cout << "count = " << count << ", calls = " << calls << "\n";
}

int main() {
    markAttendance();
    markAttendance();
    markAttendance();
    return 0;
}

count अपनी value याद रखता है; calls हर बार 0 से शुरू होता है।

static globals और static class members

• static global variable या function सिर्फ अपनी .cpp file में दिखता है (internal linkage)। Modern C++ में anonymous namespace यही काम करता है।
• static class member हर object का नहीं, पूरी class का होता है — एक साझा copy। देखें static members।

extern: files के बीच global share करना

// config.h
extern int maxStudents;        // सिर्फ declaration — अभी memory नहीं

// config.cpp
int maxStudents = 40;          // एकमात्र definition

// main.cpp
#include "config.h"
#include <iostream>
int main() {
    std::cout << maxStudents << "\n";   // 40
}

config.h include करने वाली हर file maxStudents इस्तेमाल कर सकती है, पर define सिर्फ config.cpp करती है। Header में define करने पर "multiple definition" errors आतीं।

thread_local, mutable, register और auto

• thread_local (C++11): हर thread को variable की अपनी copy मिलती है, जो thread के रहने तक रहती है।
• mutable: data member को const member function के अंदर भी बदलने देता है — caches और counters के लिए।
• register: कभी CPU register में रखने का सुझाव था; C++11 में deprecated और C++17 में हटा दिया गया। Compiler यह optimisation खुद करता है।
• auto: पुराने C/C++ में "automatic storage" था। C++11 से इसका मतलब है "type खुद निकालो": auto x = 3.5; से x double बनता है।

class Report {
    mutable int views = 0;
public:
    void show() const { views++; /* mutable है इसलिए allowed */ }
};

Storage classes की तुलना

आम गलतियाँ

• Local (automatic) variable का pointer या reference return करना — function ख़त्म होते ही वह नष्ट हो जाता है।
• Non-static local से calls के बीच value याद रखने की उम्मीद करना।
• कई files में include होने वाले header में global को declare की जगह define कर देना।
• Global variables का ज़रूरत से ज़्यादा इस्तेमाल, जिससे programs test और debug करना मुश्किल होता है।
• Modern C++ में register int i; लिखना — C++17 में यह error है।

सारांश

• Scope = नाम कहाँ दिखता है; lifetime = variable कितनी देर मौजूद रहता है।
• Local variables automatic होते हैं: अपने block के साथ बनते और नष्ट होते हैं।
• static locals calls के बीच value रखते हैं; static globals file-private होते हैं।
• extern दूसरी file में defined global को declare करता है।
• register हट चुका है; auto अब type deduction है; mutable और thread_local खास मामले हैं।

संबंधित: functions, static members, namespaces।