Computer >> कंप्यूटर ट्यूटोरियल >  >> प्रोग्रामिंग >> C++

C में 'volatile' क्वालिफायर

volatile क्वालिफायर का अर्थ

यहां हम देखेंगे कि C++ में volatile क्वालिफायर का क्या अर्थ है। volatile क्वालिफायर को वेरिएबल डिक्लेयर करते समय लागू किया जाता है। इसका उपयोग कंपाइलर को यह बताने के लिए किया जाता है कि मान किसी भी समय बदल सकता है। ये volatile के कुछ गुण हैं।

  • volatile कीवर्ड मेमोरी असाइनमेंट को नहीं हटा सकता
  • यह वेरिएबल्स को रजिस्टर में कैश नहीं कर सकता
  • असाइनमेंट के क्रम में मान नहीं बदल सकता

volatile का उपयोग कैसे करें

volatile int a;
int volatile a;

ये दोनों डिक्लेरेशन्स सही हैं। अन्य डेटा टाइप्स की तरह, हम volatile पॉइंटर्स, स्ट्रक्चर्स, यूनियन्स आदि का उपयोग कर सकते हैं। वोलेटाइल स्ट्रक्चर्स और यूनियन्स स्वयं वोलेटाइल हो सकते हैं, और उनके मेंबर वेरिएबल्स भी वोलेटाइल टाइप के हो सकते हैं।

volatile का उपयोग कहां करें

  • मेमोरी-मैप्ड पेरिफेरल रजिस्टर्स (हार्डवेयर रजिस्टर्स)
  • ग्लोबल वेरिएबल्स जिन्हें इंटरप्ट सर्विस रूटीन (ISR) द्वारा एक्सेस किया जाता है
  • मल्टी-थ्रेडेड एप्लिकेशन्स में शेयर्ड वेरिएबल्स (हालांकि C++11 में std::atomic पसंदीदा है)
  • सिग्नल हैंडलर्स द्वारा संशोधित वेरिएबल्स

उदाहरण: volatile के साथ और बिना

// बिना volatile - कंपाइलर ऑप्टिमाइज़ कर सकता है
int main() {
    int value = 0;
    while (value == 0) {
        // कंपाइलर मान सकता है कि value कभी नहीं बदलता
        // और लूप को अनंत लूप में ऑप्टिमाइज़ कर सकता है
    }
}

// volatile के साथ - कंपाइलर को हर बार मेमोरी से पढ़ना होगा
int main() {
    volatile int value = 0;
    while (value == 0) {
        // हार्डवेयर/ISR द्वारा value बदला जा सकता है
        // कंपाइलर हर इटरेशन में मेमोरी से पढ़ेगा
    }
}

volatile क्या करता है

ऑप्टिमाइज़ेशनबिना volatilevolatile के साथ
रजिस्टर कैशिंगअनुमतनिषिद्ध
डेड कोड एलिमिनेशनअनुमतनिषिद्ध (रीड्स/राइट्स रखे जाते हैं)
रीऑर्डरिंगअनुमतवोलेटाइल एक्सेस के सापेक्ष निषिद्ध
कॉमन सबएक्सप्रेशन एलिमिनेशनअनुमतवोलेटाइल एक्सेस के लिए निषिद्ध

volatile क्या नहीं करता

  • एटॉमिसिटी प्रदान नहीं करता - थ्रेड सेफ्टी के लिए std::atomic उपयोग करें
  • मेमोरी बैरियर नहीं जोड़ता - CPU रीऑर्डरिंग अभी भी हो सकती है
  • कैश कॉहेरेंसी नहीं देता - हार्डवेयर-निर्भर
  • इंटरप्ट सेफ्टी नहीं देता - केवल कंपाइलर ऑप्टिमाइज़ेशन रोकता है

सही उपयोग: हार्डवेयर रजिस्टर

// हार्डवेयर रजिस्टर मैप
struct HardwareRegisters {
    volatile uint32_t status;   // रीड-ओनली स्टेटस रजिस्टर
    volatile uint32_t control;  // रीड/राइट कंट्रोल रजिस्टर
    volatile uint32_t data;     // डेटा रजिस्टर
};

// मैप्ड एड्रेस पर पॉइंटर
volatile HardwareRegisters* hw = (HardwareRegisters*)0x40000000;

void writeData(uint32_t d) {
    hw->data = d;           // हार्डवेयर को लिखें
    hw->control = 0x1;      // ऑपरेशन ट्रिगर करें
    while (!(hw->status & 0x1)) { /* वेट */ }  // पोलिंग - volatile आवश्यक!
}

C++11 और बाद: std::atomic

मल्टी-थ्रेडेड प्रोग्रामिंग के लिए, volatile **पर्याप्त नहीं** है। std::atomic का उपयोग करें:

#include <atomic>

std::atomic<int> shared_counter(0);

void threadFunc() {
    for (int i = 0; i < 1000; ++i)
        shared_counter.fetch_add(1, std::memory_order_relaxed);
}
  1. C++ में लाइन रिफ्लेक्शन - Y-अक्ष के समानांतर सममित रेखा जांचें C++ में लाइन रिफ्लेक्शन - Y-अक्ष के समानांतर सममित रेखा जांचें

    समस्या विवरण मान लीजिए हमारे पास 2D तल पर n बिंदु हैं, हमें जांचना है कि क्या y-अक्ष के समानांतर कोई रेखा है जो दिए गए बिंदुओं को सममित रूप से प्रतिबिंबित करती है, दूसरे शब्दों में, जांचें कि क्या कोई ऐसी रेखा मौजूद है जो सभी बिंदुओं को दी गई रेखा पर प्रतिबिंबित करने के बाद मूल बिंदुओं का समुच्चय प

  1. C++ में डायगोनल ट्रैवर्स II C++ में डायगोनल ट्रैवर्स II

    मान लीजिए हमारे पास nums नामक लिस्ट ऑफ लिस्ट है, हमें nums के सभी एलिमेंट्स को डायगोनल क्रम में दिखाना है।इसलिए, यदि इनपुट हैतो आउटपुट होगा [1,6,2,8,7,3,9,4,12,10,5,13,11,14,15,16]इसे हल करने के लिए, हम निम्न चरणों का पालन करेंगे:एक ऐरे ret परिभाषित करेंएक 2D ऐरे v परिभाषित करेंi := 0 से शुरू करें,

  1. - C# में Enum (एन्यूमरेशन): परिभाषा और बुनियादी उपयोग

    Enum (Enumeration) नामित स्थिरांकों (named constants) का समूह है। डिफ़ॉल्ट रूप से मान 0 से शुरू होकर 1 से बढ़ते हैं। कोड पठनीयता और टाइप सेफ्टी के लिए उपयोगी। बुनियादी उदाहरण using System; public class Demo { public enum Vehicle { Car, // 0 Bus, // 1 Truck //