Newsgroup: it.comp.lang.c++
Titolo: Operatori logici unari e binari

Sara' banale, ma mi chiedevo:
Dato che le condizioni non fanno altro che restituire un valore tra vero e
falso che vengono interpretati come 1 e 0, quando usare l'operatore binario
da effetti diversi dall'usare quello unario?
Ad esempio per quale coppia (x, y)
if (x && y) != if (x & y) ?

 if (x&&  y) != if (x&  y) ?
Per esempio (1, 2)
Ciao.

 un giretto sul K&R :-)
Si scusa, mi sono espresso male, anche & e | sono binari dato che si
applicano a due operandi :D
Comunque il senso del mio post non cambia. 

 Per esempio (1, 2)
A livello numerico magari si, ma se si tratta di condizioni?
Ad esempio la condizione (x > y) restituice 1 o 0 quindi applicando un
operatore bitwise il calcolo della verità corrisponde.

 Ora, secondo me (e non solo) 00000001 != 00001000.
Non dico di usare i logici al posto dei bitwise ma viceversa.

Noixe wrote:

è come se dicessi di usare il "*" al posto del "+".
sono 2 operatori diversi.
-- 
By ZeD

Vito De Tullio wrote:

Dipende dal contesto. E a me sembra che usandoli nelle condizioni diventino
equivalenti.
Prova questo:
#include <iostream>
int a = 1, b = 2, c = 3;
int main()  {
 
 
        if (a > b && b < c)
                std::cout << "&& Vero" << std::endl;
        else
                std::cout << "&& Falso" << std::endl;
        if (a > b & b < c)
                std::cout << "& Vero" << std::endl;
        else
                std::cout << "& Falso" << std::endl;
 
 
        if (a < b && c > b)
                std::cout << "&& Vero" << std::endl;
        else
                std::cout << "&& Falso" << std::endl;
        if (a < b & c > b)
                std::cout << "& Vero" << std::endl;
        else
                std::cout << "& Falso" << std::endl;
 
 
        if (a > b ||  b < c)
                std::cout << "|| Vero" << std::endl;
        else
                std::cout << "|| Falso" << std::endl;
        if (a > b | b < c)
                std::cout << "| Vero" << std::endl;
        else
                std::cout << "| Falso" << std::endl;
 
 
        if (a < b || c > b)
                std::cout << "|| Vero" << std::endl;
        else
                std::cout << "|| Falso" << std::endl;
        if (a < b | c > b)
                std::cout << "| Vero" << std::endl;
        else
                std::cout << "| Falso" << std::endl;
 
        return 0;
} 

Noixe ha scritto:

ma scusa ...
1 && 2 = VERO
1 & 2 = FALSO
dove starebbe l'equivalenza ?
ciao
soviet

 diventino equivalenti.
è anche vero che 2*2 == 2+2, ma non per questo mi verrebbe in testa di
scambiarli -.-
inoltre, spesso, mi trovo a valutare direttamente le variabili (penso a
puntatori o cose del genere). E in questo caso i 2 operatori *hanno* valori
diversi.
-- 
By ZeD

 cosa, io getto la spugna. :-)
Non ho mai detto che siano la stessa cosa, mi sembra solo che i bitwise
possano essere utilizzati nelle condizioni nel momento in cui queste
ritornano come valore 1 o 0.

 dove starebbe l'equivalenza ?
Ho già precisato prima che mi riferisco a condizioni il cui risultato è 1 o
0, quindi quelle che fanno uso degli operatori relazionali (esclusi quelli
definiti dal programmatore che potrebbero ritornare altri valori).
(1 < 2) && (2 >= 1) -> VERO
(1 < 2) & (2 >= 1) -> VERO
("Ciao" != "Ciao") || ("A" > "B") -> FALSO
("Ciao" != "Ciao") | ("A" > "B") -> FALSO

 0, 
ahhhh, scusami
Si allora si, se restringi il dominio a quei soli due stati, 
penso anche io che non sussista differenza (non saprei se 
questo valga anche per l'efficienza del codice macchina sotto).
Sorry avevo misinterpretato
ciao
Soviet


 da effetti diversi dall'usare quello unario?
entrambi sono binari (2 argomenti)
&& è cortocircuitato 
http://it.wikipedia.org/wiki/Valutazione_a_corto_circuito
l'effetto è diverso se la valutazione del secondo operando ha side
effects
Mauro

 l'efficienza del codice macchina sotto).
In primo luogo, la parola "condizione" non significa un'espressione
relazionale, bensi' l'argomento di un'istruzione di controllo.
per esempio, nel seguente codice:
   if (a < b && b < c)
oppure nel seguente:
   while (a < b && b < c)
l'espressione "a < b && b < c" e' la condizione rispettivamente 
dell'istruzione "if" e dell'istruzione "while", ma le espressioni "a < 
b" e "b < c" in questo caso non sono condizioni; sono solo espressioni 
relazionali.
In secondo luogo, gli operatori logici e i corrispondenti operatori
bit-a-bit non sono del tutto equivalente neanche se hanno come argomenti
espressioni il cui valore e' sicuramente 0 o 1.
Infatti, gli operatori bit-a-bit valutano sempre i propri argomenti,
mentre gli operatori logici hanno una valutazione "a corto circuito".
Considera il seguente programma:
   #include <iostream>
   using namespace std;
   bool f() { cout << "e"; return true; }
   int main() {
     if (1 || f()) cout << "a"; else cout << "b";
     if (1 | f()) cout << "c"; else cout << "d";
   }
Stampa "aec". Come te lo spieghi?
-- 
Carlo Milanesi
http://digilander.libero.it/carlmila

 Stampa "aec". Come te lo spieghi?
In 1 || f() la f() non viene invocata, mentre in 1 | f() si.
Ma la domanda era retorica o reale? :-D

 ritornano come valore 1 o 0.
a = 0xf0
b = 0x0f
(a & b) = 0
(a && b) = 1
Non puoi utilizzare l'operatore bitwise per nient'altro che operazioni 
bitwise.
Bye,
  Gabry

 questo valga anche per l'efficienza del codice macchina sotto).
Il codice sotto non e' nemmeno lontanamente parente. 
Mai sentito parlare di short-circuited evaluation?
-- 
-riko