Arduino.ru

n/8 вместо n>>3 и n%8 вместо n&7, это форма троллинга? Или тип мышления?

Скорее всего компилятор это исправит сам... но все равно как-то жутко видеть операцию mod в 8ми битном контроллере на 16 МГц.

Уточню: проблему с чем? В байте/инте/лонге бит проверить или чего?

В макросах на размер переменной нет ограничений. Какую сунешь - такая и в проверку пойдёт.

#define bitRead(value, bit) (((value) >> (bit)) & 0x01)
#define bitSet(value, bit) ((value) |= (1UL << (bit)))

wdrakula, никакого троллинга. Я этого правда не знаю.

Почему в маске & семёрка? Как она связана с 8?

Если чо то обе мои преподавательницы по информатике были тян, может это влияет.

sadman41, моя формулировка проблемы такова: я люблю использовать массивы из bool, удобно в цикле включать светодиоды. Но если это расходует памяти в 8 раз больше чем я предполагаю, то надо это как-то решать.

Это вопрос щекотливый - если пытаться экономить RAM, то придётся писать врапперы, теряя в ROM и получая потерю в производительности (mod - не дешёвая операция).

Но, положим, если светодиодов 100 штучек, то какбэ и заморачиваться нет резона, по-моему - пользуйся байтом, как битом (bool). 

вот это точно троллинг.

7=0b111, три последних бита. Это не информатика, это 4 или 5 класс школы для даунов.

100%. Проверено.

По ним же не побегаешь с индексом, насколько я понимаю.

Встречные наводящие вопросы: каков максимальный остаток от деления значения одного байта (0-255) на 8? И сколько этот остаток занимает бит в байте? И какой маске соответствует это кол-во бит?

Ответив на все эти вопросы - процитированные вопросы отпадают сами собой ;)

Я бы вместо "одного байта (0-255)" сказл бы "чего бы то ни было".

При определённом желании вполне можно побегать.

Да, спс за поправку ;)

Идём в калькулятор, получаем 255/8 = 31.25 = почти 32, то есть 0b1111 есть точно (31=1+2+4+8). 32 нету. Вывод: остаток деления, если он есть, больше половины ширины делимого?

Всё сверх той половины?

https://www.youtube.com/watch?v=PvZPfUktzoM

wdrakula, знали бы вы как в моём Усть-перезассанске преподавали естественные науки в 90х-00х годах - захотели бы растворить преподавателей в какой-нибудь кислоте. Слава яйцам, аллаху и будде что я вообще сейчас отличаю XML от HTML. Скобочки же у тегов одинаковые. Давайте для детей, даунов или за кого вы там меня держите.

Ибо раз вы неспособны объяснить ребёнку, чем именно занимаетесь, то грош вашим знаниям цена (с) по-моему Капица.

DISCLAIMER: поясняю для тех кто в танке: я знаю о битовых операциях в C следующее:

|| или, && и, ! не

| от-илить, тобишь 1101|0011=1111

& чтобы ить числа, тоесть 1101&1001=1001

^ вроде чтобы хорить, но хз. Не использую.

Всмысле, вышеперечисленные операторы я считаю арифметическими, как + -

Далее.

Я НЕ УМЕЮ ПИСАТЬ НА C.

Я умею писать на паскале. А ещё он отличается синтаксисом, вместо begin end; фигурные скобачьки. Всё.

Как? Пока что идей лучше чем в первом посте, с правками wdrakula, у меня нет.

Вот тебе, рыбёнок, экзампл.  

void setup() {
  uint8_t number, mod, bitwise;

  number = 123;
  mod = number % 8;
  bitwise = number & B00000111;

  Serial.begin(115200);
  //while(!Serial);
  Serial.print("mod: "); Serial.print(mod); Serial.print(", bitwise: ");  Serial.println(bitwise);
}

Короче, я просто запомню: x mod y (aka x % y) = x & (base2(y)-1).

PFM.

Ты лучше запомни, что единичной непрерывной битовой маской сбрасываешь всё, что равно и больше 2^n, где n - позиция первого нуля в маске. Т.е. оставляешь хвостик, который и есть остаток. А вот с твоей математикой в беду попадёшь, имхо. 

Например

  number = 123;
  mod = number % 5;
  bitwise = number & B00000100;

Идем в калькулятор, набираем там 255, затем - жмём кнопку Mod, затем - вводим 8, затем - жмём "равно". Эта операция значит - остаток от деления, т.е. 255 Mod 8, или, в языке С - 255%8. Какой результат?

Ответ: максимальный остаток от деления - всегда на единицу меньше делителя, в нашем случае (делитель 8) - это будет 7. Число 7 - это установленные три младшие бита в байте, поэтому, чтобы получить остаток от деления на 8 - достаточно сделать AND с маской с, в нашем случае: 255 & 7 = 7, или, если проверять на калькуляторе - 255, кнопка And, 7, равно.

Понятно, почему маска 7 при делителе 8?

З.Ы. На всякий оставлю это здесь, а то, пмсм, налицо непонимание, что такое остаток от деления: https://ru.wikipedia.org/wiki/%D0%94%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BE%D1%81%D1%82%D0%B0%D1%82%D0%BA%D0%BE%D0%BC

Оттуда:

Чему полностью соответствует предложенное wdrakula:

Ключевое для понимания - степень двойки ;)

С отсатками - ок. Как дёшево и изящно бегать по битовым полям?

Как правильно заметил sadman41 - это утверждение справедливо только для y = 2^n, т.е. когда делитель является степенью двойки.

Расшифруй "по битовым полям", плз. Имеется в виду

struct bitfield
{
  byte b1: 1;
  byte b2: 1;
  ...
};

??? Или просто битовое поле в его определении?

Я не могу гарантировать, что правильно понял идею из #7, но мне кажется это "структурные" однобитные переменные. Которые потом компилятор, скорее всего, через bitwise operations превращает в обычные байты по мере использования.

поясняю для тех кто в танке, приведённые здесь три операции не являются битовыми.

Ну там тоже не всё просто: в структуре может быть и член - не битовое поле. И ширина битового поля-члена может быть не один бит. И адрес битового поля получить компилятор не даст. Пмсм, в общем случае - лучше отдаться на откуп компилятору, и погасить в себе желание бегать по битовым полям структуры каким-либо способом: завтра туда добавится новое поле, и аллес. Я так вижу, во всяком случае.

А я всё ещё верю в то, что ЕвгенийП взмахнёт левым рукавом и оттуда посыплются волшебные алгоритмы замен байтмассивов на битмассивы. Потом взмахнёт правым рукавом и байт влезет шишнадцать бит.

Ну, пишете крохотный классик и потом спокойно бегаете по индексам. Вот смотрите, вот такой, например, классик (написал по-быстрому, если где облажался и кто-нить укажет - хорошо, но так вроде на первый взгляд работает).

#ifndef	BOOLARRAY_H
#define BOOLARRAY_H

template <byte nSize> struct CBoolArray {
	struct CunningBool {
		byte & bt, mask;
		CunningBool(byte & _bt, byte _mask) : bt(_bt), mask(_mask) {}
		operator bool(void) { return static_cast<bool> (bt & mask); }
		bool operator = (const bool b) { return (bt = b ? bt | mask : bt & ~mask); }
	};
	byte anArray[(nSize + 7) / 8];
	CBoolArray(void) { memset(anArray, 0, sizeof(anArray)); }
	CunningBool operator [] (int n) { return CunningBool (anArray[n / 8], 1 << (n % 8)); }
};

#endif	//	BOOLARRAY_H

Как видите, сутевых здесь всего 11 строк.

Теперь спокойно объявляете массив в таком виде

CBoolArray<количество> booleanArray;

и пользуете его именно как масив, по индексам. Места он занимает ровно столько, сколько нужно.

Вот пример использования:

#include "Printing.h"
#include "BoolArray.h"

static const int8_t totalBools = 15;

static CBoolArray<totalBools> booleanArray;

//
// Печать массива.
// Обратите внимание, что для печати "TRUE" и "FALSE" мы используем 
//	элемент массива в качестве bool в операторе "?"
//
void printArray(const char * title) {
	Serial << "*** " << title << "\r\n";
	for (int8_t i = 0; i < totalBools; i++) {
		Serial << "booleanArray[" << i << "]=" 
			<< (booleanArray[i] ? "TRUE" : "FALSE") << "\r\n";
	}
	Serial << "-------------------------------\r\n";
}

void setup(void) {
	Serial.begin(57600);
	// 
	// Убедимся, что размер правильный
	Serial << "sizeof(booleanArray) = " << sizeof(booleanArray) << "\r\n";
	//
	//	Печатаем массив. Там сначала все false
	printArray("All elements are FALSE");
	//
	//	Делаем все true и опять печатаем
	for (int8_t i = 0; i < totalBools; booleanArray[i] = true, ++i);
	printArray("All elements are TRUE");
	//
	//	Делаем чётные элементы false, а нечётные - true
	for (int8_t i = 0; i < totalBools; booleanArray[i] = (i % 2), ++i);
	printArray("Even elements are FALSE while odd elements are TRUE");
}

void loop(void) {}

Вот результат работы, как видите, всё правильно и размер массива - 2 байта, т.е. для 15 булов - то, что доктор прописал.

sizeof(booleanArray) = 2
*** All elements are FALSE
booleanArray[0]=FALSE
booleanArray[1]=FALSE
booleanArray[2]=FALSE
booleanArray[3]=FALSE
booleanArray[4]=FALSE
booleanArray[5]=FALSE
booleanArray[6]=FALSE
booleanArray[7]=FALSE
booleanArray[8]=FALSE
booleanArray[9]=FALSE
booleanArray[10]=FALSE
booleanArray[11]=FALSE
booleanArray[12]=FALSE
booleanArray[13]=FALSE
booleanArray[14]=FALSE
-------------------------------
*** All elements are TRUE
booleanArray[0]=TRUE
booleanArray[1]=TRUE
booleanArray[2]=TRUE
booleanArray[3]=TRUE
booleanArray[4]=TRUE
booleanArray[5]=TRUE
booleanArray[6]=TRUE
booleanArray[7]=TRUE
booleanArray[8]=TRUE
booleanArray[9]=TRUE
booleanArray[10]=TRUE
booleanArray[11]=TRUE
booleanArray[12]=TRUE
booleanArray[13]=TRUE
booleanArray[14]=TRUE
-------------------------------
*** Even elements are FALSE while odd elements are TRUE
booleanArray[0]=FALSE
booleanArray[1]=TRUE
booleanArray[2]=FALSE
booleanArray[3]=TRUE
booleanArray[4]=FALSE
booleanArray[5]=TRUE
booleanArray[6]=FALSE
booleanArray[7]=TRUE
booleanArray[8]=FALSE
booleanArray[9]=TRUE
booleanArray[10]=FALSE
booleanArray[11]=TRUE
booleanArray[12]=FALSE
booleanArray[13]=TRUE
booleanArray[14]=FALSE
-------------------------------

UPDATE:
На самом деле, с memset я погорячился. Для маленьких массивов (а тут будут только такие), обычный цикл работает быстрее. Кто будет использовать, лучше замените.

UPDATE2:
Заметил, что забыл сделать возможность присваивать элементы массива друг другу. Может, и не нужно, но, для полноты операций, лучше сделать. Вот версия класса с возможностью такого присваивания:

#ifndef	BOOLARRAY_H
#define BOOLARRAY_H

template <byte nSize> struct CBoolArray {
	struct CunningBool {
		byte & bt, mask;
		CunningBool(byte & _bt, byte _mask) : bt(_bt), mask(_mask) {}
		operator bool(void) { return static_cast<bool> (bt & mask); }
		bool operator = (const bool b) { return (bt = b ? bt | mask : bt & ~mask); }
		bool operator = (CunningBool & other) { return static_cast<bool>(*this = static_cast<bool>(other)); }
	};
	byte anArray[(nSize + 7) / 8];
	CBoolArray(void) { memset(anArray, 0, sizeof(anArray)); }
	CunningBool operator [] (int n) { return CunningBool (anArray[n / 8], 1 << (n % 8)); }
};

#endif	//	BOOLARRAY_H

Теперь понятно.

Ну дык у меня других ситуаций и не будет, если я буду заводить всегда n байтов, я ж соображаю что нужно целое число байтов, неважно 5 битов там в последнем используется или все 8.

ЕвгенийП, спасибо. Возможно, я даже найду и пойму самостоятельно - а почему ноль в memset, или что-то ещё. То что 1<<число это бит 1 на нужном месте, которое задаёт "число", я знаю на опыте чтения CyberLib. Возможно, даже потом буду писать нечто подобное. О том, что в C (или C++, как его там) можно переназначать дефайнами любое нечто в любое другое нечто, я впринципе знаю, но применять это знание, очевидно, мне не позволяет некая фундаментальная тупость.

Не знаю, может совсем мимо кассы.., но год назад я смело писал вместо if (a==1&&b==1)...  if(a==1&b==1)... и всё работало как задумано было. В отличии от "=" и "==". Но если разницу между равно и тождественно равно нам в школе объясняли, то разницу между && и & (пардон за тавтологию) понять сходу непросто.

 А сама тема актуальна, вчера подправил свой скетч для куба через "битрид" и "битврайт" (спасибо за прошлогоднюю подсказку "деду Семёну") и добыл (216-27) нужных в другом массиве байт.  

нальёшь при случае. 

Принципиальной разницы - нет, понимаю, что одиночный значок относится к битовым операциям, а двойной к проверке условий (т.е. в одном случае проверка-сравнение, в другом изменение).

Концептуально, как я понимаю, разница такова: в сложном условии при использовании '&&' вычисление условия остановится на первом же false-результате, а при '&' будет доведено до конца, а только потом проанализирован результат.

Ну вот, а меня упрекнули (не помню на каком ресурсе), что я использую & неправильно и аргумент про работоспособность не в счёт. 

результатом && является булево значение 0/не 0, а результатом & - обычное арифметическое 

Мужики, а может кто-то объяснить, какая нахрен половая разница между случаями, когда в структуре есть явно указанный пустой конструктор без параметров и случаем, когда никакого конструктора нет?

Вот так всё замечательно работает

struct A  {
	int a;
};

void setup(void) {
	Serial.begin(57600);
	struct A first[] = {{1}, {11}};
	Serial.print("first[0].a=");
	Serial.print(first[0].a); 
	Serial.print("; first[1].a=");
	Serial.println(first[1].a);
}

void loop(void) {}

А вот так - хрентам

struct A  {
	A(void) {}
	int a;
};

void setup(void) {
	Serial.begin(57600);
	struct A first[] = {{1}, {11}};
	Serial.print("first[0].a=");
	Serial.print(first[0].a); 
	Serial.print("; first[1].a=");
	Serial.println(first[1].a);
}

void loop(void) {}

Правильно упрекнули

Работоспособность проявляется в частном случае, а поскольку Вы не понимаете в каком именно - значит она у Вас случайная - до первых граблей.

Мы с сыном тоже эту тему трём и, он меня убедил в правильности ООП )))

Так-то да, но в приведённом примере ( if(a==1&b==1) ) они совпадают и действительно трудно уловить разницу.

Почистить? Или один хрен читать не будете?

Чтобы потом поциэнт сказал, что Океания никогда не воевала с Остазией?

Да, я как к поциенту отношусь как Губерман к власти: «Я не люблю любую власть, мы с каждой не в ладу, но я, покуда есть что класть, на каждую кладу» (И. Губерман). Он ведь по-любому найдёт, что сбрехать, что бы мы ни делали.

Ворота! Я тут согласен с Евгением. Ты - знаешь, а те, кто не знает, не знают также - нахера им это знать!

Какого лешего тебя понесло в анализ (модифицированного веществами) сознания создателей стандарта С++?

Дык, Влад, пятница ж!

Ну, видать, неудачно пошутил - звиняйте :-)

Это очень доходчиво и понятно.

Меньше знаешь - крепче спишь (проще - дубоватей решения:)

Только ещё и #34 поймите, там более важное свойство этих операций обсуждается

https://www.it-rem.ru/logicheskoe-i-pobitovoe-i.html

Вот здесь мельком прочитал (надо убегать на выпускной к дочке), вроде ясно всё - итог будет один, вопрос траты времени на проверку всех условий. Ведь так? Если одно утверждение в цепочке ложь, то и всё будет ложь при одинарном или двойном значке. Просто по привычке одинарный значок считал логическим "и".