Olá, gostaria de saber se existe uma forma de compactar a condicional if utilizando da seguinte expressão:
if (digitalRead(2) == HIGH && digitalRead(3) == HIGH) { // read two switches
// ...
}
observe que o termo HIGH é redundante. Teria como eu colocá-lo em "evidência" para que fosse utilizado apenas uma vez?
Algo como:
if ((digitalRead(2) && digitalRead(3)) == HIGH) { // read two switches
// ...
}
Na compilação, não é apontado erro, mas a condicional não segue desta forma.
Grato!
yago4xd:
observe que o termo HIGH é redundante. Teria como eu colocá-lo em "evidência" para que fosse utilizado apenas uma vez?
Não.
Podes, se quiseres escrever a condição como:
if (digitalRead(2) && digitalRead(3)) { // read two switches
// ...
}
Mas estás a assumir que a macro HIGH tem um valor diferente de zero.
Eu pessoalmente detesto ver código assim porque não acho que seja fácil de ler e, de certa forma, destrói a flexibilidade de usar macros, bem como criar a possibilidade de em caso de mudança de plataforma dar erro.
Já agora, se quiseres testar se ambos os pinos estavam a zero, farias:
if (!digitalRead(2) && !digitalRead(3)) { // read two switches
// ...
}
Optimizar codigo diretamente modificando ele em C, Pascal, Basic etc... não é uma boa ideia porque são linguagem "compilados". Ao seja, a fim da conta vão se tornar "asm".
Vc pode optimizar ASM, calculando tamanho e tempo de cada instrução, mas vc não sabe como o compilator C vai transformar o seu codigo.
De verdade o que vc deve fazer e tentar modificar o codigo e depois da compilaçao, ler o tamaho que indica o IDE.
Depois de testar:
if (!digitalRead(2) && !digitalRead(3))
if (digitalRead(2) && digitalRead(3))
if (digitalRead(2) == HIGH && digitalRead(3) == HIGH)
os 3 usam exatamente o mesma quantidade de memoria. 
Entendo. A ideia era para compactar bytes, onde eu comparava dezenas de arrays declarados como byte por um específico.
Por exemplo, no escopo do programa, tinha o seguinte
byte card1[5] = {01,12,63,38,87};
byte card2[5] = {56,52,93,84,75};
byte card3[5] = {51,12,23,33,45};
byte card4[5] = {21,17,73,74,61};
E eventualmente, no loop, possuía uma comparação entre um valor lido e um desses cards.
for (int i = 0; i < 5; i++){
if (cardLido[i] == card1[i] || cardLido[i] == card2[i]...){
cardOk = true;
}else{
cardOk = false;
}
}
O que pretendia fazer era evidenciar meu cardLido, para que usasse apenas uma vez
for (int i = 0; i < 5; i++){
if (cardLido[i] == (card1[i] || card2[i]...){
cardOk = true;
}else{
cardOk = false;
}
}
Mas logo vi que não ser funcionaria.
No ponto de vista do tamaho do codigo (memoria usada), isso vai mudar nada. E, como falei bubulindo isso vai complicar a "leitura" do codigo.
Já agora... é possível sim optimizar código em C.
É preciso é, antes de mais saber em que dominio é feita a optimização (precisão, tamanho, memória ou rapidez) e depois implementar em C código que seja melhor nesse aspecto.
A Atmel, por via das dúvidas criou um documento para esse efeito.
bubulindo:
Já agora... é possível sim optimizar código em C.É preciso é, antes de mais saber em que dominio é feita a optimização (precisão, tamanho, memória ou rapidez) e depois implementar em C código que seja melhor nesse aspecto.
A Atmel, por via das dúvidas criou um documento para esse efeito.
Muito interesante!
Obrigado!