Tüm bitleri true olarak ayarlamak için -1 kullanmak güvenli midir?

Bu kalıbın C & C ++ 'da çok kullanıldığını gördüm.

unsigned int flags = -1;  // all bits are true

Bu, bunu başarmanın iyi bir taşınabilir yolu mu? Ya da kullanıyor mu 0xffffffffyoksa ~0daha mı iyi?

En basit olanı olduğu için tam olarak gösterdiğiniz gibi yapmanızı tavsiye ederim. Gerçek işaret temsilinden bağımsız olarak her zaman-1 işe yarayacak olanı başlatın , ancak bazen şaşırtıcı davranışlara sahip olursunuz çünkü doğru işlenen türüne sahip olmanız gerekir. Ancak o zaman bir türün en yüksek değerini elde edersiniz .~unsigned

Olası bir sürpriz örneği için şunu düşünün:

unsigned long a = ~0u;

Tüm bitleri 1 olan bir kalıbı mutlaka saklamaz a. Ama önce bir içindeki tüm bitleri 1 olan bir model oluşturacak unsigned intve sonra onu atayacaktır a. Daha unsigned longfazla bit olduğunda olan şey, bunların hepsinin 1 olmamasıdır.

Ve iki olmayanın tümleyen temsilinde başarısız olacak olan şunu düşünün:

unsigned int a = ~0; // Should have done ~0u !

Bunun nedeni, ~0tüm bitleri tersine çevirmek zorunda olmasıdır. Tersine çevirme, -1ikinin tamamlayıcı makinesinde (ihtiyacımız olan değer bu!) Sonuç verecek , ancak başka bir temsilde sonuç vermeyecektir-1 . Birinin tamamlayıcı makinesinde sıfır verir. Böylece, birinin tamamlayıcı makinesinde yukarıdakiler asıfıra başlayacaktır .

Anlamanız gereken şey, her şeyin değerlerle ilgili olmasıdır - bitlerle değil. Değişken bir değer ile başlatılır . Başlatıcıda, başlatma için kullanılan değişkenin bitlerini değiştirirseniz, değer bu bitlere göre üretilecektir. aMümkün olan en yüksek değere başlamak için ihtiyacınız olan değer -1veya UINT_MAX. İkinci tipine bağlıdır a- Kullanmak gerekecektir ULONG_MAXbir için unsigned long. Ancak, ilki türüne bağlı olmayacak ve en yüksek değeri elde etmenin güzel bir yoludur.

Biz edilir değil olmadığı hakkında konuşurken -1(her zaman sahip değildir) tüm bitlerini birine sahiptir. Ve biz konum değil olmadığı hakkında konuşurken ~0bütün bitleri bir (elbette vardır) sahiptir.

Ancak bahsettiğimiz şey, başlatılmış flagsdeğişkenin sonucunun ne olduğu. Ve bunun için sadece-1 her tür ve makineyle çalışacaktır.

• unsigned int flags = -1; taşınabilir.
• unsigned int flags = ~0; taşınabilir değildir çünkü ikinin tamamlayıcı temsiline dayanır.
• unsigned int flags = 0xffffffff; taşınabilir değildir çünkü 32 bitlik girişler varsayar.

Tüm bitleri C standardı tarafından garanti edilen bir şekilde ayarlamak istiyorsanız, ilkini kullanın.

Açıkçası tüm fff'lerin daha okunaklı olduğunu düşünüyorum. Bunun bir antipattern olduğu yorumuna gelince, eğer tüm bitlerin ayarlanmış / temizlenmiş olmasını gerçekten umursuyorsanız, muhtemelen değişkenin boyutunu önemsediğiniz bir durumda olduğunuzu iddia ediyorum, bu da hızlanma gibi bir şey gerektirir :: uint16_t vb.

Bahsedilen problemlerden kaçınmanın bir yolu basitçe yapmaktır:

unsigned int flags = 0;
flags = ~flags;

Taşınabilir ve isabetli.

C ++ 'da bayraklar için işaretsiz bir int kullanmanın iyi bir fikir olduğundan emin değilim. Bit kümesi ve benzerleri ne olacak?

std::numeric_limit<unsigned int>::max()daha iyidir çünkü 0xffffffffişaretsiz int değerinin 32 bitlik bir tamsayı olduğunu varsayar.

unsigned int flags = -1;  // all bits are true

"Bunu başarmanın [,] taşınabilir bir yolu bu mu?"

Taşınabilir? Evet .

İyi? Bu başlıkta gösterilen tüm karışıklıkların da gösterdiği gibi tartışmalı . Programcı arkadaşlarınızın kodu kafa karıştırmadan anlayabileceği kadar net olmak, iyi kod için ölçtüğümüz boyutlardan biri olmalıdır.

Ayrıca, bu yöntem derleyici uyarılarına eğilimlidir . Derleyicinizi sakatlamadan uyarıyı ortadan kaldırmak için, açık bir atama yapmanız gerekir. Örneğin,

unsigned int flags = static_cast<unsigned int>(-1);

Açık atama, hedef türüne dikkat etmenizi gerektirir. Hedef türüne dikkat ediyorsanız, doğal olarak diğer yaklaşımların tuzaklarından kaçınacaksınız.

Tavsiyem, hedef türüne dikkat etmek ve örtük dönüşüm olmadığından emin olmak olacaktır. Örneğin:

unsigned int flags1 = UINT_MAX;
unsigned int flags2 = ~static_cast<unsigned int>(0);
unsigned long flags3 = ULONG_MAX;
unsigned long flags4 = ~static_cast<unsigned long>(0);

Programcı arkadaşlarınız için hepsi doğru ve daha açık .

Ve C ++ 11 ile : autoBunlardan herhangi birini daha da basitleştirmek için kullanabiliriz:

auto flags1 = UINT_MAX;
auto flags2 = ~static_cast<unsigned int>(0);
auto flags3 = ULONG_MAX;
auto flags4 = ~static_cast<unsigned long>(0);

Doğruyu ve aşikarlığı sadece doğrudan daha iyi buluyorum.

-1'i herhangi bir işaretsiz türe dönüştürmek , standart tarafından hepsi-bir ile sonuçlanacağı garanti edilir . Bunun kullanımı ~0Ugenellikle kötüdür çünkü 0türü vardır unsigned intve açıkça böyle bir şey yazmadığınız sürece daha büyük bir işaretsiz türün tüm bitlerini doldurmaz ~0ULL. Aklı başında sistemlerde, ~0ile aynı olmalıdır -1, ancak standart tek-tamamlama ve işaret / büyüklük gösterimlerine izin verdiği için, kesinlikle taşınabilir değildir.

Elbette 0xfffffffftam olarak 32 bite ihtiyacınız olduğunu biliyorsanız yazmak her zaman uygundur , ancak birden çok türde çalışan makrolar gibi türün boyutunu bilmeseniz bile -1'in herhangi bir bağlamda çalışması avantajı vardır veya türün boyutu uygulamaya göre değişiyorsa. Hani türü yaparsanız, başka güvenli yolu sınır makroları olan tüm olanları almak için UINT_MAX, ULONG_MAX, ULLONG_MAXvb

Şahsen ben her zaman -1 kullanıyorum. Her zaman işe yarar ve bunun hakkında düşünmek zorunda değilsin.

İçerdiğiniz öğelerden #include <limits.h>birine sahip olduğunuz sürece , yalnızca kullanmalısınız

unsigned int flags = UINT_MAX;

Eğer uzun bir süre bitmek istiyorsanız, kullanabilirsiniz

unsigned long flags = ULONG_MAX;

Bu değerlerin, işaretli tamsayıların nasıl uygulandığına bakılmaksızın, sonucun tüm değer bitlerinin 1 olarak ayarlanması garanti edilir.

Evet. Diğer cevaplarda da belirtildiği gibi -1, en taşınabilir olanıdır; ancak, çok anlamsal değildir ve derleyici uyarılarını tetikler.

Bu sorunları çözmek için şu basit yardımcıyı deneyin:

static const struct All1s
{
    template<typename UnsignedType>
    inline operator UnsignedType(void) const
    {
        static_assert(std::is_unsigned<UnsignedType>::value, "This is designed only for unsigned types");
        return static_cast<UnsignedType>(-1);
    }
} ALL_BITS_TRUE;

Kullanımı:

unsigned a = ALL_BITS_TRUE;
uint8_t  b = ALL_BITS_TRUE;
uint16_t c = ALL_BITS_TRUE;
uint32_t d = ALL_BITS_TRUE;
uint64_t e = ALL_BITS_TRUE;

-1 şey yapmazdım. Oldukça sezgisel değil (en azından benim için). İmzalı verinin işaretsiz bir değişkene atanması, sadece şeylerin doğal düzeninin ihlali gibi görünüyor.

Senin durumunda her zaman kullanırım 0xFFFF. (Elbette değişken boyut için doğru sayıda F kullanın.)

[BTW, gerçek dünya kodunda yapılan -1 numarasının çok nadir olduğunu görüyorum.]

Eğer gerçekten bir vairable bit'lerin umurumda, ayrıca, sabit-genişliğini kullanmaya başlamak iyi bir fikir olacağını uint8_t, uint16_t, uint32_ttürleri.

Intel'in IA-32 işlemcilerinde, 0xFFFFFFFF'yi 64 bitlik bir kayda yazmak ve beklenen sonuçları almak sorun değil. Bunun nedeni, IA32e'nin (IA32'nin 64-bit uzantısı) yalnızca 32-bit anlıkları desteklemesidir. 64-bit komutlarda, 32-bit anındalar işaret- 64-bit'e genişletilmiştir .

Aşağıdakiler yasa dışıdır:

mov rax, 0ffffffffffffffffh

Aşağıdakiler RAX'e 64 1 koyar:

mov rax, 0ffffffffh

Tamlık için, aşağıdaki RAX'in (EAX olarak da bilinir) alt kısmına 32 1 koyar:

mov eax, 0ffffffffh

Ve aslında 0xffffffff'ı 64 bitlik bir değişkene yazmak istediğimde programlarım başarısız oldu ve bunun yerine 0xffffffffffffffff aldım. C'de bu şöyle olacaktır:

uint64_t x;
x = UINT64_C(0xffffffff)
printf("x is %"PRIx64"\n", x);

sonuç:

x is 0xffffffffffffffff

Bunu, 0xFFFFFFFF'nin 32 bit varsaydığını söyleyen tüm cevaplara bir yorum olarak göndermeyi düşündüm, ancak o kadar çok kişi cevapladı ki, bunu ayrı bir cevap olarak ekleyeceğimi düşündüm.

Sorunların çok net bir açıklaması için litb'nin cevabına bakın.

Benim anlaşmazlığım, çok açık bir şekilde konuşursak, her iki durumda da hiçbir garantinin olmamasıdır. Tüm bitler kümesinde olduğu gibi 'bit sayısının gücüne ikiden küçük bir' işaretsiz değerini temsil etmeyen herhangi bir mimari bilmiyorum, ancak burada Standardın söylediği şey (3.9.1 / 7 artı Not 44):

İntegral türlerinin gösterimleri, değerleri saf bir ikili sayı sistemi kullanarak tanımlayacaktır. [Not 44:] 0 ve 1 ikili rakamlarını kullanan tamsayılar için bir konumsal gösterim, burada ardışık bitler tarafından temsil edilen değerlerin toplayıcı olduğu, 1 ile başladığı ve 2'nin ardışık integral gücü ile çarpıldığı, belki de bit hariç en yüksek konum.

Bu, bitlerden birinin herhangi bir şey olma olasılığını bırakır.

Her ne kadar 0xFFFF(ya da0xFFFFFFFF , vb.) Okunması daha kolay , aksi takdirde taşınabilir olan koddaki taşınabilirliği bozabilir. Örneğin, bir veri yapısındaki kaç öğenin belirli bit setine sahip olduğunu saymak için bir kitaplık rutini düşünün (tam bitler arayan tarafından belirtilir). Rutin, bitlerin neyi temsil ettiğine dair tamamen bilinemez olabilir, ancak yine de "tüm bitler kümesi" sabitine sahip olması gerekir. Böyle bir durumda -1, herhangi bir bit boyutunda çalışacağından, onaltılık sabitten çok daha iyi olacaktır.

Diğer olasılık, typedefbit maskesi için bir değer kullanılırsa, ~ (bitMaskType) 0 kullanmak olacaktır; bit maskesi yalnızca 16 bit türü olmak olur, bu ifade sadece 16 bit ( 'int' aksi 32 bit olacaktır bile) ayarlayın ancak 16 bit gerekli olduğunu tüm olacağından, işler ince olmalıdır olacak sağlanan kimse o aslında typecast'te uygun türü kullanır.

Bu arada, formun ifadeleri, longvar &= ~[hex_constant]eğer onaltılık sabiti bir yerine sığamayacak kadar büyükse int, ancak bir unsigned int. Bir int16 bit ise, o zaman longvar &= ~0x4000;veya longvar &= ~0x10000; bir bitini silecek longvar, ancak longvar &= ~0x8000;bit 15'i ve bunun üzerindeki tüm bitleri temizleyecektir. Yerine uyan değerler int, tamamlayıcı operatörün bir türe uygulanmasını sağlar int, ancak sonuç long, üst bitleri ayarlayarak işaret genişletilmiş olur . İçin çok büyük olan değerler unsigned int, türe tamamlayıcı operatörün uygulanmasını sağlar long. Bununla birlikte, bu boyutlar arasında olan değerler, tümleme operatörünü yazıya uygulayacak ve unsigned intdaha sonra longişaret uzantısı olmadan yazıya dönüştürülecektir .

Pratik olarak: Evet

Teorik olarak: Hayır.

-1 = 0xFFFFFFFF (veya platformunuzda int ne büyüklükte olursa olsun) yalnızca ikinin tümleyen aritmetiğiyle doğrudur. Pratikte işe yarayacak, ancak ikinin tamamlayıcı gösterimi yerine gerçek bir işaret bitine sahip olduğunuz eski makineler (IBM ana bilgisayarları vb.) Var. Önerilen ~ 0 çözümünüz her yerde çalışmalıdır.

Diğerlerinin de belirttiği gibi -1, tüm bitleri 1'e ayarlanmış olarak işaretsiz bir türe dönüşecek bir tamsayı oluşturmanın doğru yoludur. Bununla birlikte, C ++ 'daki en önemli şey doğru türleri kullanmaktır. Bu nedenle, probleminizin doğru cevabı (sorduğunuz sorunun cevabını içerir) şudur:

std::bitset<32> const flags(-1);

Bu her zaman tam olarak ihtiyacınız olan bit miktarını içerecektir. std::bitsetDiğer cevaplarda belirtilen nedenlerle tüm bitleri 1'e ayarlanmış bir a oluşturur.

Kesinlikle güvenlidir, çünkü -1 her zaman mevcut tüm bitlere sahip olacaktır, ancak ~ 0'ı daha çok seviyorum. -1 bir için pek mantıklı değil unsigned int. 0xFF... türün genişliğine bağlı olduğu için iyi değildir.

Diyorum:

int x;
memset(&x, 0xFF, sizeof(int));

Bu her zaman size istenen sonucu verecektir.

İşaretsiz bir tür için tüm bitleri bire atamanın, verilen tür için mümkün olan maksimum değeri almaya
ve sorunun kapsamını tüm işaretsiz tam sayı türlerine genişletmeye eşdeğer olduğu gerçeğinden yararlanarak :

-1 atama , hem C hem de C ++ için herhangi bir işaretsiz tam sayı türü (işaretsiz int, uint8_t, uint16_t, vb.) İçin çalışır.

Alternatif olarak, C ++ için şunlardan birini yapabilirsiniz:

1. Dahil et <limits>ve kullanstd::numeric_limits< your_type >::max()
2. Özel bir şablonlu işlev yazın (Bu aynı zamanda bazı mantıklı kontrollere izin verir, yani hedef türü gerçekten imzasız bir türse)

Amaç, daha fazla netlik eklemek olabilir, çünkü atama -1her zaman bazı açıklayıcı yorumlara ihtiyaç duyacaktır.

Anlamı biraz daha açık hale getirmenin ve yine de türü tekrar etmekten kaçınmanın bir yolu:

const auto flags = static_cast<unsigned int>(-1);

evet, gösterilen gösterim çok doğrudur, sanki bunu tersi yaparsak u bir operatörün tüm bitleri tersine çevirmesini gerektirecektir, ancak bu durumda, makinedeki tamsayıların boyutunu dikkate alırsak mantık oldukça basittir.

örneğin çoğu makinede bir tamsayı 2 bayt = 16 bit tutabileceği maksimum değer 2 ^ 16-1 = 65535 2 ^ 16 = 65536'dır

0% 65536 = 0 -1% 65536 = 65535 hangi 1111 ............. 1'e karşılık gelir ve tüm bitler 1'e ayarlanmıştır (eğer kalıntı sınıfları mod 65536'yı düşünürsek) bu nedenle çoktur basit.

sanırım

hayır, bu fikri göz önünde bulundurursanız, işaretsiz girişler için mükemmel bir yemek olur ve aslında işe yarar

sadece aşağıdaki program parçasını kontrol edin

int main () {

unsigned int a=2;

cout<<(unsigned int)pow(double(a),double(sizeof(a)*8));

unsigned int b=-1;

cout<<"\n"<<b;

getchar();

return 0;

}

b = 4294967295 için yanıt, 4 baytlık tam sayılarda -1% 2 ^ 32

dolayısıyla işaretsiz tamsayılar için mükemmel bir şekilde geçerlidir

herhangi bir tutarsızlık durumunda plzz raporu