C++ => std :: एटोमिक्स

परमाणु प्रकार

प्रत्येक तात्कालिकता और std::atomic का पूर्ण विशेषज्ञता std::atomic टेम्पलेट एक परमाणु प्रकार को परिभाषित करता है। यदि एक थ्रेड परमाणु वस्तु पर लिखता है जबकि दूसरा थ्रेड इसे पढ़ता है, तो व्यवहार अच्छी तरह से परिभाषित है (डेटा के विवरण के लिए मेमोरी मॉडल देखें)

इसके अलावा, परमाणु वस्तुओं तक पहुंच अंतर-थ्रेड सिंक्रोनाइज़ेशन स्थापित कर सकती है और std::memory_order द्वारा निर्दिष्ट गैर-परमाणु मेमोरी एक्सेस का आदेश दे std::memory_order ।

std :: atomic किसी भी TriviallyCopyable type T. std::atomic साथ TriviallyCopyable type T. std::atomic किया जा सकता है TriviallyCopyable type T. std::atomic न तो TriviallyCopyable type T. std::atomic योग्य है और न ही चल योग्य है।

मानक पुस्तकालय एसटीडी की विशेषज्ञता प्रदान करता है :: निम्न प्रकारों के लिए परमाणु टेम्पलेट:

bool के प्रकार और उसके टाइप किए गए नाम के लिए एक पूर्ण विशेषज्ञता को परिभाषित किया गया है जिसे गैर-विशिष्ट std::atomic<T> रूप में माना जाता है, सिवाय इसके कि इसमें मानक लेआउट, तुच्छ डिफ़ॉल्ट निर्माणकर्ता, तुच्छ विध्वंसक, और समग्र प्रारंभिक सिंटैक्स है:

टंकित नाम	पूर्ण विशेषज्ञता
`std::atomic_bool`	`std::atomic<bool>`

2) पूर्ण प्रकार और अभिन्न प्रकार के लिए टाइप किए गए, निम्नानुसार हैं:

टंकित नाम	पूर्ण विशेषज्ञता
`std::atomic_char`	`std::atomic<char>`
`std::atomic_char`	`std::atomic<char>`
`std::atomic_schar`	`std::atomic<signed char>`
`std::atomic_uchar`	`std::atomic<unsigned char>`
`std::atomic_short`	`std::atomic<short>`
`std::atomic_ushort`	`std::atomic<unsigned short>`
`std::atomic_int`	`std::atomic<int>`
`std::atomic_uint`	`std::atomic<unsigned int>`
`std::atomic_long`	`std::atomic<long>`
`std::atomic_ulong`	`std::atomic<unsigned long>`
`std::atomic_llong`	`std::atomic<long long>`
`std::atomic_ullong`	`std::atomic<unsigned long long>`
`std::atomic_char16_t`	`std::atomic<char16_t>`
`std::atomic_char32_t`	`std::atomic<char32_t>`
`std::atomic_wchar_t`	`std::atomic<wchar_t>`
`std::atomic_int8_t`	`std::atomic<std::int8_t>`
`std::atomic_uint8_t`	`std::atomic<std::uint8_t>`
`std::atomic_int16_t`	`std::atomic<std::int16_t>`
`std::atomic_uint16_t`	`std::atomic<std::uint16_t>`
`std::atomic_int32_t`	`std::atomic<std::int32_t>`
`std::atomic_uint32_t`	`std::atomic<std::uint32_t>`
`std::atomic_int64_t`	`std::atomic<std::int64_t>`
`std::atomic_uint64_t`	`std::atomic<std::uint64_t>`
`std::atomic_int_least8_t`	`std::atomic<std::int_least8_t>`
`std::atomic_uint_least8_t`	`std::atomic<std::uint_least8_t>`
`std::atomic_int_least16_t`	`std::atomic<std::int_least16_t>`
`std::atomic_uint_least16_t`	`std::atomic<std::uint_least16_t>`
`std::atomic_int_least32_t`	`std::atomic<std::int_least32_t>`
`std::atomic_uint_least32_t`	`std::atomic<std::uint_least32_t>`
`std::atomic_int_least64_t`	`std::atomic<std::int_least64_t>`
`std::atomic_uint_least64_t`	`std::atomic<std::uint_least64_t>`
`std::atomic_int_fast8_t`	`std::atomic<std::int_fast8_t>`
`std::atomic_uint_fast8_t`	`std::atomic<std::uint_fast8_t>`
`std::atomic_int_fast16_t`	`std::atomic<std::int_fast16_t>`
`std::atomic_uint_fast16_t`	`std::atomic<std::uint_fast16_t>`
`std::atomic_int_fast32_t`	`std::atomic<std::int_fast32_t>`
`std::atomic_uint_fast32_t`	`std::atomic<std::uint_fast32_t>`
`std::atomic_int_fast64_t`	`std::atomic<std::int_fast64_t>`
`std::atomic_uint_fast64_t`	`std::atomic<std::uint_fast64_t>`
`std::atomic_intptr_t`	`std::atomic<std::intptr_t>`
`std::atomic_uintptr_t`	`std::atomic<std::uintptr_t>`
`std::atomic_size_t`	`std::atomic<std::size_t>`
`std::atomic_ptrdiff_t`	`std::atomic<std::ptrdiff_t>`
`std::atomic_intmax_t`	`std::atomic<std::intmax_t>`
`std::atomic_uintmax_t`	`std::atomic<std::uintmax_t>`

Std :: atomic_int का उपयोग करने का सरल उदाहरण

#include <iostream>       // std::cout
#include <atomic>         // std::atomic, std::memory_order_relaxed
#include <thread>         // std::thread

std::atomic_int foo (0);

void set_foo(int x) {
  foo.store(x,std::memory_order_relaxed);     // set value atomically
}

void print_foo() {
  int x;
  do {
    x = foo.load(std::memory_order_relaxed);  // get value atomically
  } while (x==0);
  std::cout << "foo: " << x << '\n';
}

int main ()
{
  std::thread first (print_foo);
  std::thread second (set_foo,10);
  first.join();
  //second.join();
  return 0;
}
//output: foo: 10

Modified text is an extract of the original Stack Overflow Documentation

के तहत लाइसेंस प्राप्त है CC BY-SA 3.0

से संबद्ध नहीं है Stack Overflow

C++
std :: एटोमिक्स

खोज…

परमाणु प्रकार