इंटरलाक्ड इंस्ट्रूमेंट उपयोग

Question

फ़ंक्शन InterlockedIncrement के बारे में पढ़ने के दौरान मैंने यह टिप्पणी देखी कि वेरिएबल पास 32-बिट सीमा पर गठबंधन होना चाहिए। आम तौर पर मैं कोड है जो इस तरह InterlockedIncrement का उपयोग करता है देखा है:

class A 
{ 
public: 
    A(); 
    void f(); 

private: 
    volatile long m_count; 
}; 

A::A() : m_count(0) 
{ 
} 

void A::f() 
{ 
    ::InterlockedIncrement(&m_count); 
} 

मल्टी-प्रोसेसर सिस्टम में ठीक से ऊपर कोड काम करता है या मैं इस के लिए कुछ और ध्यान रखना चाहिए?

Answer 1

यह आपके कंपाइलर सेटिंग्स पर निर्भर करता है। हालांकि, डिफ़ॉल्ट रूप से, कुछ आठ बाइट्स और नीचे प्राकृतिक सीमा पर गठबंधन किया जाएगा। इस प्रकार एक "int" हम 32-बिट सीमा पर गठबंधन किया जाएगा।

इसके अलावा, "#pragma पैक" निर्देश का उपयोग संकलन इकाई के अंदर संरेखण को बदलने के लिए किया जा सकता है।

मैं यह जोड़ना चाहता हूं कि उत्तर माइक्रोसॉफ़्ट सी/सी ++ कंपाइलर मानता है। पैकिंग नियम कंपाइलर से कंपाइलर से भिन्न हो सकते हैं। लेकिन आम तौर पर, मैं मानता हूं कि विंडोज़ के लिए अधिकांश सी/सी ++ कंपाइलर माइक्रोसॉफ्ट एसडीके हेडर के साथ काम करने के लिए बस एक ही पैकिंग डिफ़ॉल्ट का उपयोग करते हैं।

Answer 2

कोड ठीक दिखता है (वैरिएबल ठीक से गठबंधन किए जाएंगे जबतक कि आप इसे तोड़ने के लिए विशेष रूप से कुछ नहीं करते - आमतौर पर कास्टिंग या 'पैक' संरचनाएं शामिल करते हैं)।

Answer 3

हां, यह ठीक काम करेगा। कंपाइलर आमतौर पर संरेखित करते हैं जब तक अन्यथा निर्देश नहीं दिया जाता है।

Answer 4

कड़ाई से बोलते हुए, यह वास्तव में आपके ए के उपयोग पर निर्भर करता है - उदाहरण के लिए, यदि आप एक "ए" ऑब्जेक्ट को एक खोल ITEMIDLIST के भीतर पैक करते हैं, या खराब "प्राग्मा पैक" वाली संरचना को डेटा ठीक से गठबंधन नहीं किया जा सकता है।