Чи безпечно використовувати -1 для встановлення всіх біт на істину?

Я бачив, як цей зразок багато використовувався в C & C ++.

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

Це хороший портативний спосіб досягти цього? Або використовуєте 0xffffffffчи ~0краще?

Я рекомендую зробити це саме так, як ви показали, оскільки це найбільш прямий вперед. Ініціалізуйте, до -1якого працюватимуть завжди , незалежно від фактичного представлення знаків, тоді як ~іноді буде дивовижна поведінка, оскільки вам доведеться мати правильний тип операнду. Тільки тоді ви отримаєте найбільш високе значення unsignedтипу.

Для прикладу можливого сюрпризу розглянемо цей:

unsigned long a = ~0u;

Це не обов'язково зберігатиме шаблон з усіма бітами 1 на a. Але він спочатку створить шаблон із усіма бітами 1 в unsigned int, а потім призначить його a. Що відбувається, коли unsigned longмає більше бітів, це те, що не всі з них є 1.

І врахуйте це, яке не вдасться у представленні доповнення, яке не є двома:

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

Причиною тому є те, що ~0має інвертувати всі біти. Інверсія , що дасть -1на двійкове доповнення машині (це значення нам потрібно!), Але НЕ вихід -1на інше уявлення. На машині, що доповнює, це дає нуль. Таким чином, на машині доповнення, зазначене вище ініціалізується aна нуль.

Що ви повинні розуміти, це те, що це все в значеннях, а не в бітах. Змінна ініціалізується зі значенням . Якщо в ініціалізаторі ви модифікуєте біти змінної, використовуваної для ініціалізації, значення буде сформовано відповідно до цих бітів. Значення, яке потрібно для ініціалізації aдо максимально можливого значення, є -1або UINT_MAX. Другий буде залежати від типу a- вам потрібно буде використовувати ULONG_MAXдля unsigned long. Однак перший не буде залежати від його типу, і це приємний спосіб отримати максимально високе значення.

Ми не говоримо про те, чи -1має всі біти один (він не завжди є). І ми не говоримо про те, чи ~0є всі біти один (він, звичайно, є).

Але про що ми говоримо - це результат ініціалізованої flagsзмінної. А для цього працюватимуть лише-1 з кожним типом і машиною.

• unsigned int flags = -1; є портативним.
• unsigned int flags = ~0; не є портативним, оскільки він спирається на представлення двох доповнень.
• unsigned int flags = 0xffffffff; не є портативним, оскільки він передбачає 32-бітні вставки.

Якщо ви хочете встановити всі біти способом, гарантованим стандартом C, використовуйте перший.

Відверто кажучи, я думаю, що всі FFF-і є читабельнішими. Щодо коментаря, що його антипатерн, якщо вам дійсно все одно, що всі біти встановлені / очищені, я б заперечував, що ви, мабуть, перебуваєте у ситуації, коли ви все одно переймаєтесь розміром змінної, що закликає щось подібне до збільшення :: uint16_t тощо.

Спосіб, який дозволяє уникнути згаданих проблем, - це просто зробити:

unsigned int flags = 0;
flags = ~flags;

Переносний і до речі.

Я не впевнений, що використання непідписаного int для прапорів - це гарна ідея в першу чергу в C ++. Що з бітсетом тощо?

std::numeric_limit<unsigned int>::max()краще, тому що 0xffffffffприпускає, що непідписаний int є 32-бітним цілим числом.

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

"Це хороший [,] портативний спосіб досягти цього?"

Портативний? Так .

Добре? Дискусійний , про що свідчить вся плутанина, показана на цій темі. Бути достатньо зрозумілим, що ваші колеги-програмісти можуть розуміти код без плутанини, має бути одним із вимірів, які ми вимірюємо для хорошого коду.

Також цей метод схильний до попереджень компілятора . Щоб уникнути попередження без каліцтва компілятора, вам знадобиться чіткий склад. Наприклад,

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

Явний виступ вимагає, щоб ви звернули увагу на цільовий тип. Якщо ви звернете увагу на цільовий тип, то, природно, уникнете підводних каменів інших підходів.

Моя порада полягає в тому, щоб звернути увагу на цільовий тип і переконатися, що немає неявних перетворень. Наприклад:

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

Усі вони правильні та очевидніші для ваших колег-програмістів.

І з C ++ 11 : Ми можемо використовувати autoбудь-яке з них ще простіше:

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

Я вважаю правильним і очевидним краще, ніж просто правильним.

Перетворення -1 у будь-який непідписаний тип гарантується стандартом, щоб у результаті вийшло все-єдине. Використання, ~0Uяк правило, погано, оскільки 0має тип unsigned intі не заповнить усі біти більшого типу без підпису, якщо тільки ви явно не напишете щось подібне ~0ULL. У здорових системах ~0має бути ідентичним -1, але оскільки стандарт дозволяє представити доповнення та знаки / величини, строго кажучи, це не портативно.

Звичайно, завжди добре виписувати, 0xffffffffякщо ви знаєте, що вам потрібно точно 32 біта, але -1 має ту перевагу, що він буде працювати в будь-якому контексті, навіть коли ви не знаєте розмір типу, наприклад, макроси, які працюють на декількох типах або якщо розмір типу змінюється залежно від реалізації. Якщо ви знаєте тип, інший безпечний спосіб , щоб отримати все-онов є межа макросів UINT_MAX, ULONG_MAX, ULLONG_MAXі т.д.

Особисто я завжди використовую -1. Це завжди працює, і вам не доведеться думати про це.

Поки у вас є #include <limits.h>одна з ваших частин, вам слід просто використовувати

unsigned int flags = UINT_MAX;

Якщо ви хочете, щоб довгі коштували біти, ви можете використовувати

unsigned long flags = ULONG_MAX;

Гарантовано, що для цих значень всі біти значення результату встановлені на 1, незалежно від того, як реалізуються підписані цілі числа.

Так. Як згадується в інших відповідях, -1є найбільш портативним; однак це не дуже смислово і запускає попередження компілятора.

Щоб вирішити ці проблеми, спробуйте цей простий помічник:

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;

Використання:

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 речі. Це досить неінтуїтивно (мені щонайменше). Присвоєння підписаних даних непідписаній змінній просто здається порушенням природного порядку речей.

У вашій ситуації я завжди користуюся 0xFFFF. (Використовуйте потрібну кількість Fs для змінного розміру курсу.)

[BTW, я дуже рідко бачу трюк -1, виконаний у реальному коді.]

Крім того, якщо ви дійсно дбаєте про окремі бітів в vairable, було б гарною ідеєю , щоб почати роботу з фіксованою шириною uint8_t, uint16_t, uint32_tтипи.

На процесорах IA-32 від Intel нормально записати 0xFFFFFFFF в 64-розрядний реєстр і отримати очікувані результати. Це відбувається тому, що IA32e (64-розрядне розширення до IA32) підтримує лише 32-бітні прямі. У 64-розрядних інструкціях 32-розрядні безпосередні розширення знаків на 64-бітні.

Наступне незаконне:

mov rax, 0ffffffffffffffffh

Нижче наведено 64 1 в RAX:

mov rax, 0ffffffffh

Для повноти, нижче розміщується 32 1s у нижній частині RAX (він же EAX):

mov eax, 0ffffffffh

Насправді у мене були програми, коли я хотів записати 0xffffffff на 64-бітну змінну, і натомість отримав 0xffffffffffffffffff. У З це було б:

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

результат:

x is 0xffffffffffffffff

Я думав опублікувати це як коментар до всіх відповідей, де сказано, що 0xFFFFFFFF передбачає 32 біти, але так багато людей відповіли на це, я подумав, що додаю це як окрему відповідь.

Дивіться відповідь лампа для дуже чіткого пояснення проблем.

Моя незгода полягає в тому, що, строго кажучи, жодних випадків немає гарантій. Я не знаю жодної архітектури, яка не представляє непідписане значення "один менше двох до потужності кількості біт", як всі встановлені біти, але ось що насправді говорить Стандарт (3.9.1 / 7 плюс примітка 44):

Представлення інтегральних типів мають визначати значення за допомогою чистої двійкової системи числення. [Примітка 44:] Позиційне подання для цілих чисел, які використовують двійкові цифри 0 і 1, в яких значення, представлені послідовними бітами, є адитивними, починаються з 1 і множать на послідовну інтегральну потужність 2, за винятком, можливо, біта з найвища посада.

Це залишає можливість для одного з бітів взагалі будь-що.

Хоча 0xFFFF(або0xFFFFFFFF тощо) може бути легше читати, він може порушити портативність у коді, який інакше був би портативним. Розглянемо, наприклад, процедуру бібліотеки, щоб підрахувати, скільки елементів у структурі даних мають певні біти, встановлені (точні біти визначає абонент). Процедура може бути абсолютно агностичною щодо того, що представляють біти, але все ж потрібно мати постійну "всі біти". У такому випадку -1 буде набагато кращим, ніж шістнадцяткова константа, оскільки він буде працювати з будь-яким розміром бітів.

Іншою можливістю, якщо typedefзначення використовується для бітової маски, було б використовувати ~ (bitMaskType) 0; якщо бітмаска має лише 16-бітний тип, цей вираз матиме лише 16 біт (навіть якщо 'int' інакше буде 32 біта), але оскільки 16 біт буде все необхідне, все повинно бути добре за умови, що один фактично використовує відповідний тип у typecast.

Між іншим, вирази форми longvar &= ~[hex_constant]мають жахливий гатч, якщо шестигранна константа занадто велика, щоб вміститись у int, але вміститься в ан unsigned int. Якщо an int- 16 біт, то longvar &= ~0x4000;або longvar &= ~0x10000; очистить один біт longvar, але longvar &= ~0x8000;очистить біт 15 і всі біти вище цього. Значення, які вписуються, intбуде застосовувати оператор доповнення до типу int, але результат буде розширений знаком long, встановлюючи верхні біти. Значення, які занадто великі, для unsigned intоператора доповнення застосовуватимуть тип long. Значення, які знаходяться між цими розмірами, однак застосовуватимуть оператор доповнення до типу unsigned int, який потім буде перетворений у тип longбез розширення знаків.

Практично: Так

Теоретично: Ні.

-1 = 0xFFFFFFFF (або будь-який розмір інти на вашій платформі) відповідає лише арифметиці доповнення двох. На практиці це буде працювати, але там є застарілі машини (мейнфрейми IBM тощо), де у вас є фактичний біт знаків, а не представлення комплектуючих двох. Пропоноване рішення ~ 0 повинне працювати всюди.

Як уже згадували інші, -1 - це правильний спосіб створити ціле число, яке перетвориться на непідписаний тип із усіма бітами, встановленими на 1. Однак найважливішим у C ++ є використання правильних типів. Тому правильна відповідь на вашу проблему (яка включає відповідь на поставлене запитання) така:

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

Це завжди буде містити точну кількість бітів, що вам потрібно. Він будує a std::bitsetз усіма бітами, встановленими на 1, з тих же причин, які вказані в інших відповідях.

Це, безумовно, безпечно, оскільки -1 завжди матиме всі доступні біти, але мені подобається ~ 0 краще. -1 просто не має великого сенсу для unsigned int. 0xFF... це не добре, оскільки це залежить від ширини типу.

Я кажу:

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

Це завжди дасть бажаний результат.

Використання того факту, що присвоєння всіх бітів одному для непідписаного типу еквівалентно прийняттю максимально можливого значення для даного типу
та розширенню сфери питання на всі неподписані цілі цілі :

Призначення -1 працює для будь-якого непідписаного цілого числа (unsigned int, uint8_t, uint16_t тощо) для C і C ++.

В якості альтернативи для C ++ ви можете:

1. Включати <limits> та використовуватиstd::numeric_limits< your_type >::max()
2. Напишіть спеціальну функцію шаблону (Це також дозволить перевірити правильність, тобто якщо тип призначення дійсно непідписаний тип)

Цілі можуть бути ще більш чіткі, оскільки при призначенні -1завжди потрібні пояснення.

Спосіб зробити сенс трохи більш очевидним і все ж уникнути повторення типу:

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

так, подане представлення дуже коректно, як якщо б ми це зробили, то навпаки u вимагатиме від оператора повернути всі біти, але в цьому випадку логіка є досить простою, якщо врахувати розмір цілих чисел у машині

наприклад, у більшості машин ціле число становить 2 байти = 16 біт, максимальне значення якого може містити - 2 ^ 16-1 = 65535 2 ^ 16 = 65536

0% 65536 = 0 -1% 65536 = 65535, котрий похиляється до 1111 ............. 1, а всі біти встановлені на 1 (якщо вважати залишкові класи mod 65536), отже, це набагато прямо вперед.

я вважаю

ні, якщо ви вважаєте це поняття, воно ідеально пообідає для непідписаних ints, і воно справді працює

просто перевірте наступний фрагмент програми

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, який становить -1% 2 ^ 32 на 4 байтні цілі числа

отже, це цілком справедливо для непідписаних цілих чисел

у випадку будь-яких невідповідностей, звітуйте про plzz