Neden C++ 11 CAS işlemleri iki işaretçi parametresi alır?

Question

C++ 11 CAS operasyonları (örneğin atomic_compare_exchange_weak, atomic_compare_exchange_strong) böyle, yani iki işaretçiler ve bir değer, almak çoğu: Buna karşılık

bool atomic_compare_exchange(T* pointer, T* expected,  // pseudodeclaration! 
          T desired); 

, Microsoft, gcc ve Intel'den CAS işlemleri

long InterlockedCompareExchange(long* pointer, long desired,  // Microsoft 
           long expected); 

int __sync_bool_compare_and_swap (T* pointer, T expected,   // gcc and 
            T desired);      // Intel 

Neden C++ 11 CAS fonksiyonları iki işaretçiler almak ve bunun yerine görünen bir değeri daha geleneksel bir işaretçi ve iki değeri olması: her bir işaretçi ve iki değeri alır?

Answer 1

C++ 11 yolu daha kullanışlıdır: Değişim başarısız olursa, *expectedyeni geçerli değere güncelleştirilmiştir. Yani kolay bir döngüde işlevini kullanmayı kolaylaştırır:

T value = x.load(); 
T newvalue = frob(value); 

while (!atomic_compare_exchange(&x, &value, newvalue)) 
{ 
    newvalue = frob(value); 
} 

Microsoft imzası ile, operasyon GCC en __sync_type sürümü için daha hantal ve aynen olduğu başarılı olup olmadığını test etmek. GCC'nin __sync_bool ile, değişim her başarısız olduğunda başka bir yük yapmanız bile gerekir.

Answer 2

Neden olmasa da neden görmedim. Benim kullanımda C++ sürümü daha az kullanışlıdır. Bir değişkenin bir değeri olana kadar beklemek istiyorum, sonra yeni bir değere ayarlamak istiyorum. GCC instrinsics ile

:

while (!__sync_bool_compare_and_swap(&value, expected, desired)) { } 

11 C++ olarak:

auto tmp = expected; 
while (!value.compare_exchange_weak(tmp,desired)) 
{ 
    tmp = expected; 
}