8 и 4 и так больше двух.

var& (F1|F2) == (F1|F2)

хотя если колво, тога функцию с

isSet(var, flag) {
  return (var & flag != 0) ? 1 : 0;
}

// и

count = isSet(var, F1) + isSet(var, F2)

и т.п.

Вполне себе решение.

Можно взять, например, gcc-изм __builtin_popcount или std::bitset::count в C++

Нужно подойти с другой стороны 2 и более флага одновременно это не один. Из свойств бит имеем - при вычитании из степени 2 единицы получим набор единичек меньших по степени. Соответственно если установлено более двух единиц это правило будет нарушено. Отсюда результат:

(x - 1) | x == x * 2 - 1 - если установлен один флаг. Если два, и более, то не выполняется.

Как-то так короче.

То есть

&31

ох ёж. пора ++ ценик.

x&(x-1) гасит левый(младшейший) бит если бит токмо один то будет ноль если popcount>1 то не нулевой.

Я ожидал этой простыни в комментах :)

Думал о чем-то подобном, но в моем случае не проканало, ибо у меня в enum'е есть еще пара флагов, которые могут быть установлены и должны игнорироваться.

Маскируй их перед вычислением, ёпт.

Да там тогда простыня получится размером с А как вы бы определили что установлено 2 и более флага одновременно? (комментарий)

А как вы бы определили что установлено 2 и более флага одновременно? (комментарий)

и кстати:

>1 или >= или «что установлены 3 или более флага одновременно»

Да там тогда простыня получится

От пары флагов простыни не получится (F1 и F2 не учитываются):

x &= !(F1 | F2);
return (x - 1) | x != x * 2 - 1;

Как-то так.

/* E */ enum SmlLStyles
{
    SML_LINE_ONLYPOINTS    = (0x000001),
    SML_LINE_ALIASED       = (0x000002),
    SML_LINE_ANTIALIASED   = (0x000004),
    SML_LINE_NOFIRSTPIXEL  = (0x000008),
    SML_LINE_NOLASTPIXEL   = (0x000016)
};

проверяю наличие одновременно установленных SML_LINE_ONLYPOINTS, SML_LINE_ALIASED и SML_LINE_ANTIALIASED. Возможно еще с пяток флагов добавится, неизвестного мне пока назначения.

return var & (var - 1) != 0;

Так а в чём суть? Проверить, стоят-ли все флаги, кроме SML_LINE_NOFIRSTPIXEL и SML_LINE_NOLASTPIXEL?

Вообще идея, что надо посчитать _количество_ флагов - какая-то странная.

Навскидку:

return var && var > 2 && var != 4 && var != 8

Алсо биты лучше объявлять так:

enum foobar {
AAA = (1<<0),
BBB = (1<<1),
CCC = (1<<2),
DDD = (1<<3),
};

Вообще идея, что надо посчитать _количество_ флагов - какая-то странная.

Но решаемая, см коменты тут: http://govnokod.ru/16375 там есть однострочник без циклов для подсчёта ненулевых бит. Но повторюсь, не это тебе надо.

0x000016

Следующий после 0x8 будет 0x10. И почему у тебя по три байта в определениях?

Блин, тупанул про 16.

И почему у тебя по три байта в определениях?

А какая разница?

Вообще идея, что надо посчитать _количество_ флагов - какая-то странная.

Я не хотел городить вот такое условие (которое обновлять - сдохнешь прежде чем корректно еще один флаг добавишь). Объясняю зачем - ALIASING, ANTIALIASING и ONLYPIXELS не могут стоять вместе, только кто-то один.

А какая разница?

Глаз резануло. Тут либо подчёркивать ёмкость хранения ведущими нулями либо просто писать 0x1, 0x2, ..., 0x10...

Я привык писать 3 байта, потому что 4 байта как-то не напишешь (ибо enum будет сводиться к signed int, а писать 0x000034FF и потом в голове инстинктивно думать, что это u32...), два байта может оказаться мало (ибо там всего 16 флагов может поместиться), а три -в самый раз.

ибо enum будет сводиться к signed int, а писать 0x000034FF

Какая разница, что к чему приводится, если ты задаёшь значения? 0x1 он что в signed, что в unsigned один хер 0x1.

Я бы сделал без signum:

if ((((var&F1) != 0) + ((var&F2) != 0) + ((var&F3) != 0) + ((var&F4) != 0)) > 1)

if (((var&F1 ? 1:0) + (var&F2 ? 1:0) + (var&F3 ? 1:0) + (var&F4 ? 1:0)) > 1)

Второй вариант, пожалуй, «чище».

Отсюда:

int NumberOfSetBits(int i)
{
     i = i - ((i >> 1) & 0x55555555);
     i = (i & 0x33333333) + ((i >> 2) & 0x33333333);
     return (((i + (i >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
}

Этот вариант значительно лучше: ты можешь и 32 флага выставить!

При незначительной правке можно данную шнягу и на 64 бита расширить!

Делай как ядро linux - припиши каунтер и ин(де)кременть его. Все гениальное просто.

С точки зрения читаемости лучший вариант, имхо:

int somefunc(flags) {
  int incompatibleflags = flags & (ALIASING|ANTIALIASING|ONLYPIXELS);
  if (incompatibleflags!=ALIASING &&
      incompatibleflags!=ANTIALIASING &&
      incompatibleflags!=ONLYPIXELS)
      return 1; //error

Вот именно так. Если уж у тебя от содержимого if такой баттхёрт, можно сократить

int isPow2(int a) {
  return !(a&(a-1));
}
int somefunc(flags) {
  int incompatibleflags = flags & (ALIASING|ANTIALIASING|ONLYPIXELS);
  if (!isPow2(incompatibleflags))
    return 1; //error

Но самым правильным способом будет совместимые опции сделать флагами, а несовместимые - отдельным enum

Помилуйте, у меня и так в функцию идет слишком много параметров.

/* E */ SmlErrors SmlRasterDrawTetrGR(SmlIndex index, SmlTetragon tetragon, SmlTetragon corners, SmlGradient grad, SmlFStyle fstyle, SmlLStyle lstyle);

Помилуйте

принято. Тебе слоник давно написал правильный ответ - только маску AND надо добавить на var для нужных полей

А как вы бы определили что установлено 2 и более флага одновременно? (комментарий)

Помилуйте, у меня и так в функцию идет слишком много параметров.

Ну если предметная область требует много параметров, то заметанием их под ковёр делу не поможешь.

Не, ну а как иначе тут сделаешь? Индекс текстуры, координаты вершин, коэффициенты скругления углов, информация о градиенте, стиль заливки и стиль линии. Из всего перечисленного не структуры - это только индекс и два последних флага.

Оформи всё это в структуру. Это полноценный state, а не просто параметры.

А засунуть параметры отрисовки в некую структуру «Рисуемый объект» почему не хочешь? Если их много можно даже индекс в массиве передавать (как ты, судя по всему, делаешь с текстурами).

И да - структуры хорошо бы по указателю (или ссылке в c++) передавать. Как бы так принято. А то они все в стек копируются.

Ну и добавь параметр к функции. Да, их много, ну будет ещё один. Всяко лучше, чем держать в голове, что некоторые флаги - не флаги вовсе, а режимы.

У него рендер же, если для каждого пикселя по указателю ходить - производительность будет не ок. Структуры «настройки рисования» тут может быть полезна, но может и не быть, я бы лишнюю сущность порождал только если она действительно нужна. Например, если критична память, то можно «настройки рисования» (флаги и режим сглаживания) упаковать чуть ли не в один байт с помощью битовых полей. Но лучше не надо.

Если с полем допустимо работать как с числом, то находим нужное в bit twiddling hacks (а там есть и вычисление числа единичных бит, и вообще всякое), иначе два флага - это не ноль и не один:

if (var && !(var == F1 || var == F2 || var == F3 || var == F4))

в общем случае - да, суммой, но вместо signum можно использовать !!

x &= !(F1 | F2);

Наверное всё-таки ~, а не !

return ((F1|F2)&~(F3|F4)) > 0;

Первая сумма «или» - какие из флагов проверяем, вторая - какие из них игнорируем/маскируем.

Забыл самое главное. Для суммы битов есть метод.

Про смешивание флагов которые могут быть установлены вместе и которые исключают друг друга здесь уже писали.

Кроме этого. Какова логика установки флагов? Возможно, самое простое решение - не устанавливать больше одного флага из тех, что исключают друг друга?

Я бы предложил еще такое решение: для каждого флага завести-захардкодить маску несовместимости, в которой на месте несовместимых с этим флагом битов стоят единицы, а остальные нули. Флаг устанавливать только когда логическое «и» текущего состояния и маски несовместимости этого флага равно нулю.

Второе решение: устанавливать флаг так («текущее состояние» и (не «маска несовместимости флага»)) или «флаг» ) то есть снимать все несовместимые с этим флагом биты.

Но лучше бы разобраться с логикой установки флагов: как получается, что несовместимые флаги пытаются устанавливаться вместе?

В некоторых процессорах есть инструкция pop, заботающая за 1 такт.

Какова логика установки флагов? Возможно, самое простое решение - не устанавливать больше одного флага из тех, что исключают друг друга?

Это функция для библиотеки. Вызывать ее будет пользователь. Строю «защиту от дурака».