Có an toàn khi sử dụng -1 để đặt tất cả các bit thành đúng không?

Tôi đã thấy mô hình này được sử dụng rất nhiều trong C & C ++.

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

Đây có phải là một cách di động tốt để thực hiện điều này? Hoặc là sử dụng 0xffffffffhoặc ~0tốt hơn?

Tôi khuyên bạn nên làm điều đó chính xác như bạn đã thể hiện, vì đó là cách đơn giản nhất. Khởi tạo để luôn-1 hoạt động , độc lập với biểu diễn dấu hiệu thực tế, trong khi đôi khi sẽ có hành vi đáng ngạc nhiên vì bạn sẽ phải có loại toán hạng phù hợp. Chỉ sau đó bạn sẽ nhận được giá trị cao nhất của một loại.~unsigned

Để biết ví dụ về một bất ngờ có thể xảy ra, hãy xem xét điều này:

unsigned long a = ~0u;

Nó sẽ không nhất thiết lưu trữ một mẫu có tất cả các bit 1 vào a. Nhưng trước tiên, nó sẽ tạo một mẫu có tất cả các bit 1 trong một unsigned int, sau đó gán nó cho a. Điều gì xảy ra khi unsigned longcó nhiều bit hơn là không phải tất cả trong số đó là 1.

Và xem xét cái này, cái này sẽ thất bại trên đại diện bổ sung không phải của hai:

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

Lý do cho điều đó là ~0phải đảo ngược tất cả các bit. Đảo ngược sẽ mang lại -1trên máy bổ sung hai (đó là giá trị chúng ta cần!), Nhưng sẽ không mang lại -1đại diện khác. Trên máy bổ sung của một người, nó mang lại số không. Do đó, trên máy bổ trợ của một người, ở trên sẽ khởi tạo avề không.

Điều bạn nên hiểu là tất cả về giá trị - không phải bit. Biến được khởi tạo với một giá trị . Nếu trong trình khởi tạo, bạn sửa đổi các bit của biến được sử dụng để khởi tạo, giá trị sẽ được tạo theo các bit đó. Giá trị bạn cần, để khởi tạoa giá trị cao nhất có thể, là -1hoặc UINT_MAX. Thứ hai sẽ phụ thuộc vào loại a- bạn sẽ cần sử dụng ULONG_MAXcho một unsigned long. Tuy nhiên, cách đầu tiên sẽ không phụ thuộc vào loại của nó và đó là một cách hay để nhận được giá trị cao nhất.

Chúng tôi không nói về việc -1có tất cả các bit một hay không (không phải lúc nào cũng có). Và chúng ta không nói về việc ~0có tất cả các bit một hay không (tất nhiên là có).

Nhưng những gì chúng ta đang nói là kết quả của flagsbiến khởi tạo là gì. Và cho nó, chỉ-1 sẽ làm việc với mọi loại và máy.

• unsigned int flags = -1; là hàng xách tay.
• unsigned int flags = ~0; không thể mang theo được vì nó phụ thuộc vào đại diện bổ sung của hai.
• unsigned int flags = 0xffffffff; không khả dụng vì nó giả sử ints 32 bit.

Nếu bạn muốn đặt tất cả các bit theo cách được đảm bảo theo tiêu chuẩn C, hãy sử dụng bit đầu tiên.

Thành thật mà nói tôi nghĩ rằng tất cả các fff là dễ đọc hơn. Đối với nhận xét rằng đó là một antipotype, nếu bạn thực sự quan tâm rằng tất cả các bit được thiết lập / xóa, tôi sẽ tranh luận rằng bạn có thể đang ở trong một tình huống mà bạn quan tâm đến kích thước của biến, dù sao cũng sẽ gọi một cái gì đó như boost :: uint16_t, v.v.

Một cách để tránh các vấn đề được đề cập là chỉ cần làm:

unsigned int flags = 0;
flags = ~flags;

Di động và đến điểm.

Tôi không chắc chắn sử dụng một int unsign cho cờ là một ý tưởng tốt ở vị trí đầu tiên trong C ++. Những gì về bitet và tương tự?

std::numeric_limit<unsigned int>::max()là tốt hơn vì 0xffffffffgiả sử int unsign là số nguyên 32 bit.

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

"Đây có phải là một cách tốt [,] di động để thực hiện điều này?"

Di động? Đúng .

Tốt chứ Tranh cãi , bằng chứng là tất cả sự nhầm lẫn được hiển thị trên chủ đề này. Rõ ràng đủ để các lập trình viên đồng nghiệp của bạn có thể hiểu mã mà không nhầm lẫn phải là một trong những thứ nguyên mà chúng tôi đo lường cho mã tốt.

Ngoài ra, phương pháp này dễ bị cảnh báo trình biên dịch . Để bỏ qua cảnh báo mà không làm tê liệt trình biên dịch của bạn, bạn cần một diễn viên rõ ràng. Ví dụ,

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

Dàn diễn viên rõ ràng yêu cầu bạn chú ý đến loại mục tiêu. Nếu bạn chú ý đến loại mục tiêu, thì đương nhiên bạn sẽ tránh được những cạm bẫy của các phương pháp khác.

Lời khuyên của tôi sẽ là chú ý đến loại mục tiêu và đảm bảo không có chuyển đổi ngầm định. Ví dụ:

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

Tất cả đều đúng và rõ ràng hơn đối với các lập trình viên của bạn.

Và với C ++ 11 : Chúng ta có thể sử dụng autođể làm cho bất kỳ thứ nào trong số này thậm chí còn đơn giản hơn:

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

Tôi xem xét đúng và rõ ràng tốt hơn đơn giản là chính xác.

Chuyển đổi -1 thành bất kỳ loại không dấu nào được đảm bảo theo tiêu chuẩn để tạo ra tất cả các loại. Việc sử dụng ~0Unói chung là xấu vì 0có loại unsigned intvà sẽ không điền vào tất cả các bit của loại không dấu lớn hơn, trừ khi bạn viết rõ ràng một cái gì đó như ~0ULL. Trên các hệ thống lành mạnh, ~0nên giống hệt với-1 , nhưng vì tiêu chuẩn cho phép các biểu diễn bổ sung và ký hiệu / cường độ, nói đúng ra nó không thể mang theo được.

Tất nhiên sẽ luôn ổn khi viết ra 0xffffffffnếu bạn biết bạn cần chính xác 32 bit, nhưng -1 có lợi thế là nó sẽ hoạt động trong mọi ngữ cảnh ngay cả khi bạn không biết kích thước của loại, chẳng hạn như macro hoạt động trên nhiều loại hoặc nếu kích thước của loại thay đổi theo cách thực hiện. Nếu bạn không biết loại, một cách an toàn để có được tất cả-những người là các macro hạn UINT_MAX, ULONG_MAX, ULLONG_MAXvv

Cá nhân tôi luôn sử dụng -1. Nó luôn hoạt động và bạn không cần phải suy nghĩ về nó.

Miễn là bạn có #include <limits.h>một trong những bao gồm của bạn, bạn chỉ nên sử dụng

unsigned int flags = UINT_MAX;

Nếu bạn muốn bit có giá trị dài, bạn có thể sử dụng

unsigned long flags = ULONG_MAX;

Các giá trị này được đảm bảo có tất cả các bit giá trị của kết quả được đặt thành 1, bất kể số nguyên đã ký được thực hiện như thế nào.

Đúng. Như đã đề cập trong các câu trả lời khác,-1 là di động nhất; tuy nhiên, nó không phải là rất ngữ nghĩa và kích hoạt cảnh báo trình biên dịch.

Để giải quyết những vấn đề này, hãy thử trợ giúp đơn giản này:

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;

Sử dụng:

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;

Tôi sẽ không làm điều -1. Nó khá là không trực quan (ít nhất là với tôi). Việc gán dữ liệu đã ký cho một biến không dấu dường như là vi phạm trật tự tự nhiên của mọi thứ.

Trong tình huống của bạn, tôi luôn luôn sử dụng 0xFFFF . (Sử dụng đúng số lượng F cho kích thước biến của khóa học.)

[BTW, tôi rất hiếm khi thấy thủ thuật -1 được thực hiện trong mã thế giới thực.]

Thêm vào đó, nếu bạn thực sự quan tâm đến các bit riêng lẻ trong một vairable, nó sẽ là ý tưởng tốt để bắt đầu sử dụng chiều rộng cố định uint8_t, uint16_t, uint32_tloại.

Trên bộ xử lý IA-32 của Intel, bạn có thể ghi 0xFFFFFFFF vào thanh ghi 64 bit và nhận được kết quả mong đợi. Điều này là do IA32e (phần mở rộng 64 bit thành IA32) chỉ hỗ trợ tức thời 32 bit. Trong hướng dẫn 64 bit, tức thời 32 bit được mở rộng đăng nhập thành 64 bit.

Sau đây là bất hợp pháp:

mov rax, 0ffffffffffffffffh

Sau đây đặt 64 1 giây trong RAX:

mov rax, 0ffffffffh

Để hoàn thiện, phần sau đây đặt 32 1s vào phần dưới của RAX (còn gọi là EAX):

mov eax, 0ffffffffh

Và trên thực tế, tôi đã có các chương trình thất bại khi tôi muốn viết 0xffffffff thành biến 64 bit và thay vào đó tôi đã nhận được 0xffffffffffffffffffff. Trong C này sẽ là:

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

kết quả là:

x is 0xffffffffffffffff

Tôi nghĩ sẽ đăng bài này như một bình luận cho tất cả các câu trả lời nói rằng 0xFFFFFFFF giả định 32 bit, nhưng rất nhiều người đã trả lời tôi nghĩ rằng tôi đã thêm nó như một câu trả lời riêng biệt.

Xem câu trả lời của litb để được giải thích rất rõ ràng về các vấn đề.

Sự không đồng ý của tôi là, nói rất nghiêm túc, không có gì đảm bảo cho cả hai trường hợp. Tôi không biết bất kỳ kiến ​​trúc nào không đại diện cho giá trị không dấu 'một ít hơn hai so với sức mạnh của số bit' như tất cả các bit được đặt, nhưng đây là những gì Tiêu chuẩn thực sự nói (3.9.1 / 7 cộng lưu ý 44):

Các biểu diễn của các kiểu tích phân sẽ xác định các giá trị bằng cách sử dụng hệ thống số nhị phân thuần túy. [Lưu ý 44:] Biểu diễn vị trí cho các số nguyên sử dụng các chữ số nhị phân 0 và 1, trong đó các giá trị được biểu thị bằng các bit liên tiếp là phụ gia, bắt đầu bằng 1 và được nhân với công suất tích phân liên tiếp là 2, ngoại trừ bit với vị trí cao nhất.

Điều đó để lại khả năng cho một trong các bit là bất cứ điều gì cả.

Mặc dù 0xFFFF(hoặc0xFFFFFFFF , v.v.) có thể dễ đọc hơn, nhưng nó có thể phá vỡ tính di động trong mã mà nếu không thì có thể mang theo được. Ví dụ, hãy xem xét một thói quen thư viện để đếm xem có bao nhiêu mục trong cấu trúc dữ liệu có các bit nhất định được đặt (các bit chính xác được chỉ định bởi người gọi). Thường trình có thể hoàn toàn không tin vào những gì các bit đại diện, nhưng vẫn cần phải có hằng số "tất cả các bit". Trong trường hợp như vậy, -1 sẽ tốt hơn rất nhiều so với hằng số hex vì nó sẽ hoạt động với bất kỳ kích thước bit nào.

Khả năng khác, nếu một typedefgiá trị được sử dụng cho bitmask, sẽ là sử dụng ~ (bitMaskType) 0; nếu bitmask chỉ xảy ra là loại 16 bit, biểu thức đó sẽ chỉ có 16 bit được đặt (ngay cả khi 'int' sẽ là 32 bit) nhưng vì 16 bit sẽ là tất cả những gì được yêu cầu, mọi thứ sẽ ổn với điều kiện là một thực sự sử dụng loại thích hợp trong typecast.

Ngẫu nhiên, các biểu thức của biểu mẫu longvar &= ~[hex_constant]có một hình ảnh khó chịu nếu hằng số hex quá lớn để phù hợp với một int, nhưng sẽ phù hợp với một unsigned int. Nếu an intlà 16 bit thì longvar &= ~0x4000;hoặc longvar &= ~0x10000; sẽ xóa một bit của longvar, nhưng longvar &= ~0x8000;sẽ xóa bit 15 và tất cả các bit ở trên đó. Các giá trị phù hợp intsẽ có toán tử bổ sung được áp dụng cho một loại int, nhưng kết quả sẽ được ký hiệu mở rộng long, thiết lập các bit trên. Các giá trị quá lớn unsigned intsẽ áp dụng toán tử bổ sung cho kiểu long. Tuy nhiên, các giá trị nằm giữa các kích thước đó sẽ áp dụng toán tử bổ sung cho kiểu unsigned int, sau đó sẽ được chuyển đổi thành kiểu longmà không có phần mở rộng dấu.

Thực tế: Có

Về mặt lý thuyết: Không.

-1 = 0xFFFFFFFF (hoặc bất kỳ kích thước nào int trên nền tảng của bạn) chỉ đúng với số học bổ sung của hai. Trong thực tế, nó sẽ hoạt động, nhưng có những máy kế thừa ngoài kia (máy tính lớn của IBM, v.v.) nơi bạn đã có một bit ký hiệu thực tế thay vì biểu diễn bổ sung của hai. Giải pháp đề xuất ~ 0 của bạn nên hoạt động ở mọi nơi.

Như những người khác đã đề cập, -1 là cách chính xác để tạo một số nguyên sẽ chuyển đổi thành loại không dấu với tất cả các bit được đặt thành 1. Tuy nhiên, điều quan trọng nhất trong C ++ là sử dụng đúng loại. Do đó, câu trả lời chính xác cho vấn đề của bạn (bao gồm câu trả lời cho câu hỏi bạn đã hỏi) là đây:

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

Điều này sẽ luôn chứa số lượng bit chính xác mà bạn cần. Nó xây dựng một std::bitsetvới tất cả các bit được đặt thành 1 vì cùng lý do được đề cập trong các câu trả lời khác.

Nó chắc chắn an toàn, vì -1 sẽ luôn có tất cả các bit có sẵn, nhưng tôi thích ~ 0 hơn. -1 chỉ không có ý nghĩa nhiều cho một unsigned int. 0xFF... không tốt vì nó phụ thuộc vào độ rộng của loại.

Tôi nói:

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

Điều này sẽ luôn cung cấp cho bạn kết quả mong muốn.

Tận dụng thực tế là việc gán tất cả các bit cho một loại cho loại không dấu tương đương với việc lấy giá trị tối đa có thể cho loại đã cho
và mở rộng phạm vi câu hỏi cho tất cả loại số nguyên không dấu :

Chỉ định -1 hoạt động cho bất kỳ dấu nào loại số nguyên (int unsign int, uint8_t, uint16_t, v.v.) cho cả C và C ++.

Để thay thế, đối với C ++, bạn có thể:

1. Bao gồm <limits> và sử dụngstd::numeric_limits< your_type >::max()
2. Viết hàm templated tùy chỉnh (Điều này cũng sẽ cho phép kiểm tra độ tỉnh táo, nghĩa là nếu loại đích thực sự là một loại không dấu)

Mục đích có thể được thêm rõ ràng hơn, vì việc gán -1sẽ luôn cần một số nhận xét giải thích.

Một cách để làm cho ý nghĩa rõ ràng hơn một chút và để tránh lặp lại kiểu:

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

vâng, biểu diễn được hiển thị rất chính xác như thể chúng ta làm theo cách khác, bạn sẽ yêu cầu một toán tử đảo ngược tất cả các bit nhưng trong trường hợp này logic khá đơn giản nếu chúng ta xem xét kích thước của các số nguyên trong máy

ví dụ trong hầu hết các máy, số nguyên là 2 byte = 16 bit giá trị tối đa có thể giữ là 2 ^ 16-1 = 65535 2 ^ 16 = 65536

0% 65536 = 0 -1% 65536 = 65535 mà corressponds thành 1111 ............. 1 và tất cả các bit được đặt thành 1 (nếu chúng ta xem xét các lớp dư lượng mod 65536) do đó nó rất nhiều thẳng về phía trước.

tôi đoán

không nếu bạn xem xét khái niệm này thì nó hoàn toàn phù hợp với số nguyên không dấu và nó thực sự có tác dụng

chỉ cần kiểm tra đoạn chương trình sau

int chính () {

unsigned int a=2;

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

unsigned int b=-1;

cout<<"\n"<<b;

getchar();

return 0;

}

câu trả lời cho b = 4294967295 whcih là -1% 2 ^ 32 trên số nguyên 4 byte

do đó, nó hoàn toàn hợp lệ cho các số nguyên không dấu

trong trường hợp có bất kỳ báo cáo plzz khác biệt