Lze tohle napsat efektivněji? – C / C++ – Fórum – Programujte.com

S C / C++ začínám a tak se chi zeptat zda lze nasledující věc řešet nějak elegantněji, přesněji řečeno efektivněji z pohledu strojového času.

Mám funkci, která je volnána v nějakém přesěndaném časovém intervalu a provádí nastvení čehosi podle bitové matice 32x16 bitů. Pro přehlednost v ukazce predpokldejme bitové pole jen 1x16 bitů. Při jaždém jednom spuštní funkce se musí zjisti stav odpovidajiciho bitu při prvním prvního, při durhém druhého při 16 šestnácténo a při 17 se jede od začátku.

//globlní proměnné
unsigned short tm;
tm = 0b0011110000111100;
unsigned char x=0;


// tělo samotné funkce
 printf("%d \n", !!tm & 1 << x));
 x++;
if(x==1 || x==4 || x==8 || x==12 || x==16)
	{
	...//nejaky kod, který se povádí každý čtvrtý průběh funkci
	if(x==16}x=0; // Po 16 průbězích začínáme od nuly
	}

Jinymi slovy ptám se zda lze unsigned short tm projit bit po bitu efektivněji než !!tm & 1 << x
Plus na to abych prošel 16x danou funkci a v ni část kodu provedl jen 4x potřebuji vyhodnoti 20x nějakou podminku. opět není stojově efektivněji řešení.

V každém případě děkuji.

asi nejlépe se to řeší přes FPGA pole :) ale jinak to mužeš řešit klasickým způsobem funkcí OR nebo AND nebo XOR atd ... samozřejmě v binární soustavě 

Ten test jednotlivých bitů máš optimální a zároveň to překladač pochopí, tak nebude vymýšlet nějaké brikule. A násobky 4 mají dolní 2 bity nulové, tak to můžeš sfouknout jedním andem. Každopádně to vypadá na nesmyslnou mikroptimalizaci, prostě takové věci neřeš dokud nemáš důvod.

A předpokládám, že ti tam uletěly nějaké závorky. Jinak to máš blbě.

Zalezi na tom, co to ma presne delat a proc. 

- pokud te zajima, zda je nejaky bit jednickovy
x & 0b00001111 > 0 // kazdy bit, ktery te zajima vynasobis ANDem s 1
// cisla 1-15

- pokud hledas konkretne ty cisla, pak je to nejlepsi moznost
x==1 || x==4 || x==8 || x==12 || x==16
Porovnani s konkretnim cislem stejne probiha takto:
a & b > 0
Ale v kodu by to melo byt o neco pomalejsi nez ==, protoze je tam operace navic,
kde neni jiste, zda pujde o >0 nebo >cislo

- a take zalezi na poradi
A || B || C to funguje tak, ze, kdyz A==true, tak B a C se uz nevyhodnocuje. Pokud se bude casteji vyskytovat C, tak rychlejsi bude poradi
C || A || B
lze treba predpokladat, ze krajni moznosti se vyskytnou malokdy
x==4 || x==8 || x==12 || x==1 || x==16
nebo se da predpokladat, ze se nizka cisla budou vyskytovat casteji
x==1 || x==4 || x==8 || x==12 || x==16 // puvodni poradi

 printf("%d \n", !!tm & 1 << x)); // ??? ( + ))
 x++;
if(x==1 || x==4 || x==8 || x==12 || x==16)
	{
	if(x==16}x=0; // ??? ( + }
	}

k tem zavorkam asi tolik :)

#1 Hufnagel

v původním kódu je pár nepřesností podmínky by měla být trošku jinak, aby to odpovídalo zadání
x++;
if(x>15) X=0;
if(x==0 || x==4... x==12) { ... }
případně lépe řešit přes modulo 4
if (x%4 ==0)

já bych to řešil rotací a vymaskováním použitelné pro různé kombo výběru pozic
unsigned short x = 0b0000000000000001;
unsigned short mask = 0b0001000100010001;

x <<=1;
if(x==0) =1; /při přetečení nastaví začátek
šlo by použít i 1-řádkově - zde výhodou může být optimalizace v kompilátoru, že vygeneruje nativní instrulci ROL - rotace posun doleva s přenosem nejvyššího bitu do nejnižšího
x = (x << 1)  |  (x >> 15); /

no a nakonec podmínka pro dané pozice
if (x && mask) 
 

EDIT:

Ještě bych se vyjádřil k printf
& má přednost před << tzn výsledek bude (tm & 1) << x což asi není úmyslem, správně, pokud se má vypsat stav bitu na pozici, by mělo být:
tm & (1 << x)

!! - dvojitá negace - v podstatě se vyruší, ale může mít vliv na normalizaci bitového výsledku ale v tom případě musí být vše správně uzávorkováno
!!(tm & (1 << x))