Apakah aman menggunakan -1 untuk mengatur semua bit menjadi true?

Saya telah melihat pola ini banyak digunakan dalam C & C ++.

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

Apakah ini cara portabel yang baik untuk mencapai ini? Atau menggunakan 0xffffffffatau ~0lebih baik?

Saya sarankan Anda untuk melakukannya persis seperti yang Anda tunjukkan, karena ini adalah yang paling mudah. Inisialisasi -1yang akan selalu bekerja , terlepas dari representasi tanda yang sebenarnya, sementara ~kadang-kadang akan memiliki perilaku yang mengejutkan karena Anda harus memiliki jenis operan yang tepat. Hanya dengan begitu Anda akan mendapatkan nilai jenis yang paling tinggi unsigned.

Untuk contoh kemungkinan kejutan, pertimbangkan yang ini:

unsigned long a = ~0u;

Itu tidak serta merta menyimpan pola dengan semua bit 1 menjadi a. Tapi itu pertama-tama akan membuat pola dengan semua bit 1 dalam unsigned int, dan kemudian menetapkannya a. Apa yang terjadi ketika unsigned longmemiliki lebih banyak bit adalah bahwa tidak semua itu adalah 1.

Dan pertimbangkan yang ini, yang akan gagal pada representasi komplemen bukan-dua:

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

Alasan untuk itu adalah bahwa ~0harus membalikkan semua bit. Melawan yang akan menghasilkan -1pada mesin pelengkap dua (yang merupakan nilai yang kita butuhkan!), Tetapi tidak akan menghasilkan -1representasi lain. Pada mesin pelengkap seseorang, hasilnya nol. Jadi, pada mesin komplemen seseorang, yang di atas akan menginisialisasi ake nol.

Hal yang harus Anda pahami adalah itu semua tentang nilai - bukan bit. Variabel diinisialisasi dengan nilai . Jika dalam initializer Anda memodifikasi bit variabel yang digunakan untuk inisialisasi, nilai akan dihasilkan sesuai dengan bit tersebut. Nilai yang Anda butuhkan, untuk menginisialisasi ake nilai setinggi mungkin, adalah -1atau UINT_MAX. Yang kedua akan tergantung pada jenis a- Anda harus menggunakan ULONG_MAXuntuk unsigned long. Namun, yang pertama tidak akan tergantung pada jenisnya, dan itu cara yang bagus untuk mendapatkan nilai tertinggi.

Kita tidak berbicara tentang apakah -1semua bit satu (tidak selalu demikian). Dan kita tidak berbicara tentang apakah ~0semuanya memiliki bit (tentu saja).

Tetapi yang kita bicarakan adalah apa hasil dari flagsvariabel yang diinisialisasi . Dan untuk itu, hanya-1 akan bekerja dengan setiap jenis dan mesin.

• unsigned int flags = -1; portabel.
• unsigned int flags = ~0; tidak portabel karena bergantung pada representasi dua-pelengkap.
• unsigned int flags = 0xffffffff; tidak portabel karena mengasumsikan int 32-bit.

Jika Anda ingin mengatur semua bit dengan cara yang dijamin oleh standar C, gunakan yang pertama.

Terus terang saya pikir semua fff lebih mudah dibaca. Mengenai komentar yang merupakan antipattern, jika Anda benar-benar peduli bahwa semua bit diatur / dihapus, saya berpendapat bahwa Anda mungkin berada dalam situasi di mana Anda peduli tentang ukuran variabel, yang akan membutuhkan sesuatu seperti dorongan :: uint16_t, dll.

Cara yang menghindari masalah yang disebutkan adalah dengan hanya melakukan:

unsigned int flags = 0;
flags = ~flags;

Portable dan to the point.

Saya tidak yakin menggunakan int unsigned untuk flag adalah ide yang bagus di C ++. Bagaimana dengan bitset dan sejenisnya?

std::numeric_limit<unsigned int>::max()lebih baik karena 0xffffffffmengasumsikan bahwa unsigned int adalah integer 32-bit.

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

"Apakah ini cara portabel yang bagus untuk mencapai ini?"

Portabel? Ya .

Baik? Luar biasa , sebagaimana dibuktikan oleh semua kebingungan yang ditampilkan di utas ini. Menjadi cukup jelas sehingga sesama programmer Anda dapat memahami kode tanpa kebingungan harus menjadi salah satu dimensi yang kami ukur untuk kode yang baik.

Juga, metode ini rentan terhadap peringatan kompiler . Untuk menghilangkan peringatan tanpa melumpuhkan kompiler Anda, Anda membutuhkan pemeran eksplisit. Sebagai contoh,

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

Pemeran eksplisit mengharuskan Anda memperhatikan jenis target. Jika Anda memperhatikan jenis target, maka Anda secara alami akan menghindari jebakan dari pendekatan lain.

Saran saya adalah memperhatikan jenis target dan memastikan tidak ada konversi tersirat. Sebagai contoh:

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);

Semuanya benar dan lebih jelas bagi sesama programmer Anda.

Dan dengan C ++ 11 : Kita dapat menggunakan autountuk membuat semua ini lebih sederhana:

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

Saya menganggap benar dan jelas lebih baik daripada hanya benar.

Mengonversi -1 menjadi jenis apa pun yang tidak ditandatangani dijamin oleh standar untuk menghasilkan semua-yang. Penggunaan ~0Uumumnya buruk karena 0memiliki tipe unsigned intdan tidak akan mengisi semua bit dari tipe unsigned yang lebih besar, kecuali jika Anda secara eksplisit menulis sesuatu seperti ~0ULL. Pada sistem waras, ~0harus identik dengan -1, tetapi karena standar memungkinkan representasi satu-pelengkap dan sign / magnitude, sebenarnya tidak portabel.

Tentu saja selalu baik-baik saja untuk menulis 0xffffffffjika Anda tahu Anda membutuhkan 32 bit, tetapi -1 memiliki keuntungan bahwa ia akan bekerja dalam konteks apa pun bahkan ketika Anda tidak tahu ukuran jenisnya, seperti makro yang bekerja pada banyak jenis. , atau jika ukuran jenis bervariasi berdasarkan implementasi. Jika Anda mengetahui jenis, cara yang aman lain untuk mendapatkan semua-yang adalah macro batas UINT_MAX, ULONG_MAX, ULLONG_MAX, dll

Secara pribadi saya selalu menggunakan -1. Itu selalu berhasil dan Anda tidak perlu memikirkannya.

Selama Anda memiliki #include <limits.h>salah satu termasuk Anda, Anda harus menggunakan

unsigned int flags = UINT_MAX;

Jika Anda ingin nilai bit yang panjang, Anda bisa menggunakannya

unsigned long flags = ULONG_MAX;

Nilai-nilai ini dijamin memiliki semua bit nilai dari hasil yang ditetapkan ke 1, terlepas dari bagaimana bilangan bulat yang ditandatangani diimplementasikan.

Iya. Seperti disebutkan dalam jawaban lain, -1adalah yang paling portabel; Namun, itu tidak terlalu semantik dan memicu peringatan kompiler.

Untuk mengatasi masalah ini, coba penolong sederhana ini:

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;

Pemakaian:

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;

Saya tidak akan melakukan hal -1. Ini agak tidak intuitif (setidaknya bagi saya). Menugaskan data yang ditandatangani ke variabel yang tidak ditandatangani sepertinya merupakan pelanggaran terhadap tatanan alami hal-hal.

Dalam situasi Anda, saya selalu menggunakan 0xFFFF. (Gunakan angka Fs yang tepat untuk ukuran variabel, tentu saja.)

[BTW, saya sangat jarang melihat trik -1 dilakukan dalam kode dunia nyata.]

Selain itu, jika Anda benar-benar peduli tentang bit individu dalam vairable, itu akan menjadi ide yang baik untuk mulai menggunakan fixed-lebar uint8_t, uint16_t, uint32_tjenis.

Pada prosesor IA-32 Intel, boleh saja menulis 0xFFFFFFFF ke register 64-bit dan mendapatkan hasil yang diharapkan. Ini karena IA32e (ekstensi 64-bit ke IA32) hanya mendukung 32-bit dengan segera. Dalam instruksi 64-bit, 32-bit langsung menandatangani diperluas ke 64-bit.

Berikut ini adalah ilegal:

mov rax, 0ffffffffffffffffh

Berikut ini menempatkan 64 1s di RAX:

mov rax, 0ffffffffh

Hanya untuk kelengkapan, berikut ini menempatkan 32 1 di bagian bawah RAX (alias EAX):

mov eax, 0ffffffffh

Dan sebenarnya saya punya program gagal ketika saya ingin menulis 0xffffffff ke variabel 64-bit dan saya mendapat 0xffffffffffffffff. Dalam C ini akan menjadi:

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

hasilnya adalah:

x is 0xffffffffffffffff

Saya pikir memposting ini sebagai komentar untuk semua jawaban yang mengatakan bahwa 0xFFFFFFFF mengasumsikan 32 bit, tetapi begitu banyak orang yang menjawabnya, saya pikir saya akan menambahkannya sebagai jawaban yang terpisah.

Lihat jawaban litb untuk penjelasan yang sangat jelas tentang masalah ini.

Ketidaksepakatan saya adalah bahwa, pada dasarnya, tidak ada jaminan untuk kedua kasus tersebut. Saya tidak tahu ada arsitektur yang tidak mewakili nilai yang tidak ditandatangani dari 'satu kurang dari dua dengan kekuatan jumlah bit' karena semua bit ditetapkan, tetapi inilah yang dikatakan oleh Standar (3.9.1 / 7 plus catatan 44):

Representasi tipe integral harus mendefinisikan nilai dengan menggunakan sistem numerasi biner murni. [Catatan 44:] Representasi posisi untuk bilangan bulat yang menggunakan angka biner 0 dan 1, di mana nilai yang diwakili oleh bit berturut-turut adalah aditif, mulai dengan 1, dan dikalikan dengan kekuatan integral berturut-turut dari 2, kecuali mungkin untuk bit dengan posisi tertinggi.

Itu meninggalkan kemungkinan salah satu bit sama sekali.

Meskipun 0xFFFF(atau 0xFFFFFFFF, dll.) Mungkin lebih mudah dibaca, ini dapat merusak portabilitas dalam kode yang seharusnya portabel. Pertimbangkan, misalnya, rutinitas pustaka untuk menghitung berapa banyak item dalam struktur data yang memiliki bit tertentu yang ditetapkan (bit yang tepat ditentukan oleh pemanggil). Rutin mungkin benar-benar agnostik untuk mewakili bit, tetapi masih perlu memiliki konstanta "semua bit". Dalam kasus seperti itu, -1 akan jauh lebih baik daripada konstanta hex karena akan bekerja dengan ukuran bit apa pun.

Kemungkinan lain, jika suatu typedefnilai digunakan untuk bitmask, adalah menggunakan ~ (bitMaskType) 0; jika bitmask kebetulan hanya tipe 16-bit, ekspresi itu hanya akan memiliki 16 bit yang ditetapkan (bahkan jika 'int' akan menjadi 32 bit) tetapi karena 16 bit adalah semua yang diperlukan, semuanya harus baik-baik saja asalkan satu sebenarnya menggunakan tipe yang sesuai dalam typecast.

Kebetulan, ekspresi dari bentuk longvar &= ~[hex_constant]memiliki gotcha yang buruk jika konstanta hex terlalu besar untuk ditampung dalam int, tetapi akan cocok dalam sebuah unsigned int. Jika an intadalah 16 bit, maka longvar &= ~0x4000;atau longvar &= ~0x10000; akan menghapus satu bit longvar, tetapi longvar &= ~0x8000;akan menghapus bit 15 dan semua bit di atas itu. Nilai-nilai yang cocok intakan memiliki operator komplemen diterapkan pada suatu jenis int, tetapi hasilnya akan diperpanjang untuk long, pengaturan bit atas. Nilai yang terlalu besar untuk unsigned intakan memiliki operator pelengkap diterapkan untuk mengetik long. Nilai-nilai yang berada di antara ukuran-ukuran itu, bagaimanapun, akan menerapkan operator pelengkap untuk mengetik unsigned int, yang kemudian akan dikonversi untuk mengetik longtanpa ekstensi tanda.

Praktis: Ya

Secara teoritis: Tidak.

-1 = 0xFFFFFFFF (atau ukuran berapapun int pada platform Anda) hanya benar dengan aritmatika komplemen dua. Dalam praktiknya, ini akan berhasil, tetapi ada mesin legacy di luar sana (mainframe IBM, dll.) Tempat Anda mendapatkan sedikit tanda yang sebenarnya daripada representasi pelengkap dua. Solusi ~ 0 yang Anda usulkan harus bekerja di mana-mana.

Seperti yang disebutkan orang lain, -1 adalah cara yang benar untuk membuat integer yang akan dikonversi ke tipe yang tidak ditandai dengan semua bit diatur ke 1. Namun, hal yang paling penting dalam C ++ adalah menggunakan tipe yang benar. Karena itu, jawaban yang benar untuk masalah Anda (yang mencakup jawaban untuk pertanyaan yang Anda ajukan) adalah ini:

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

Ini akan selalu mengandung jumlah bit yang tepat yang Anda butuhkan. Itu membangun a std::bitsetdengan semua bit diatur ke 1 untuk alasan yang sama disebutkan dalam jawaban lain.

Ini tentu aman, karena -1 akan selalu memiliki semua bit yang tersedia, tetapi saya suka ~ 0 lebih baik. -1 hanya tidak masuk akal untuk sebuah unsigned int. 0xFF... tidak baik karena tergantung pada lebar jenisnya.

Saya katakan:

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

Ini akan selalu memberi Anda hasil yang diinginkan.

Memanfaatkan fakta bahwa menetapkan semua bit ke satu untuk tipe yang tidak ditandatangani sama dengan mengambil nilai maksimum yang mungkin untuk tipe yang diberikan,
dan memperluas cakupan pertanyaan ke semua tipe integer yang tidak ditandatangani :

Menetapkan -1 berfungsi untuk semua tipe integer yang tidak ditandatangani (unsigned int, uint8_t, uint16_t, dll.) Untuk C dan C ++.

Sebagai alternatif, untuk C ++, Anda dapat:

1. Sertakan <limits>dan gunakanstd::numeric_limits< your_type >::max()
2. Tulis fungsi templated khusus (Ini juga akan memungkinkan beberapa pemeriksaan kewarasan, yaitu jika jenis tujuan benar-benar jenis yang tidak ditandai)

Tujuannya dapat menambah lebih banyak kejelasan, karena penugasan -1akan selalu membutuhkan komentar penjelasan.

Cara untuk membuat maknanya sedikit lebih jelas namun untuk menghindari pengulangan jenis:

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

ya representasi yang ditampilkan sangat benar seolah-olah kita melakukannya sebaliknya Anda akan memerlukan operator untuk membalikkan semua bit tetapi dalam hal ini logikanya cukup mudah jika kita mempertimbangkan ukuran bilangan bulat dalam mesin

misalnya dalam kebanyakan mesin integer adalah 2 byte = 16 bit nilai maksimum yang dapat ditampungnya adalah 2 ^ 16-1 = 65535 2 ^ 16 = 65536

0% 65536 = 0 -1% 65536 = 65535 yang sesuai dengan 1111 ............. 1 dan semua bit diatur ke 1 (jika kita mempertimbangkan kelas residu mod 65536) maka itu jauh lurus ke depan.

saya kira

Tidak, jika Anda mempertimbangkan gagasan ini, itu sempurna untuk ints unsigned dan itu benar-benar berhasil

cukup periksa fragmen program berikut

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;

}

jawaban untuk b = 4294967295 yang merupakan -1% 2 ^ 32 pada bilangan bulat 4 byte

oleh karena itu sangat valid untuk bilangan bulat tak bertanda

dalam hal terjadi perbedaan laporan plzz