Qual è la diffrenza tra & e && operatori in C#

Question

Sto cercando di capire la differenza tra & e & & operatori in C#. Ho cercato su internet senza molto successo. Qualcuno può spiegare con un esempio?

Answer 1

Il primo è bitwise and il secondo è boolean and.

Answer 2

& è un bitwise operatore e & & è un logico operatore che si applica a bool operandi.

Answer 3

& è l'operatore AND bit a bit. Per gli operandi di tipi interi, calcolerà l'AND bit a bit degli operandi e il risultato sarà un tipo intero. Per gli operandi booleani, calcolerà la logica e gli operandi. && è l'operatore AND logico e non funziona sui tipi di intero. Per i tipi booleani, in cui possono essere applicati entrambi, la differenza è nella proprietà "cortocircuito" di &&. Se il primo operando di && viene valutato su false, il secondo non viene valutato affatto. Questo non è il caso di &:

bool f() { 
    Console.WriteLine("f called"); 
    return false; 
} 
bool g() { 
    Console.WriteLine("g called"); 
    return false; 
} 
static void Main() { 
    bool result = f() && g(); // prints "f called" 
    Console.WriteLine("------"); 
    result = f() & g(); // prints "f called" and "g called" 
} 

|| è simile a && in questa proprietà; valuterà solo il secondo operando se il primo assume valore falso.

Ovviamente, i tipi definiti dall'utente possono sovraccaricare questi operatori facendoli fare tutto ciò che vogliono.

Answer 4

Hai amico, L'operatore & & (Operatore logico) viene utilizzato nelle istruzioni condizionali. Per esempio

if(firstName == 'Tilsan' && lastName == 'Fighter') 
{ 
     Response.Write("Welcome Tilsan The Fighter!"); 
} 

la dichiarazione Response.Write verrà eseguito solo se entrambe le variabili firstName e lastName partita alla loro condizione.

Mentre & (Bitwise Operator) operatore viene utilizzato per il binario e le operazioni, ad esempio, se scriviamo:

bool a, b, c; 

a = true; 
b = false; 

c = a & b; 

Response.Write(c); // 'False' will be written to the web page 

Qui prima Binario E operazione verrà eseguita sulle variabili a e b, e il valore risultante sarà essere memorizzati in variabile c.

Answer 5

modo facile guardare è logico & valuterà entrambi i lati del & a prescindere se il lato sinistro è falso, mentre il corto circuito & & valuterà solo il lato destro se la sinistra è vero.

d=0; 
n=10; 

// this throws divide by 0 exception because it evaluates the 
//  mod even though "d != 0" is false 
if ((d != 0) & (n % d) == 0) 
    Console.Writeline(d + " is a factor of " + n); 

// This will not evaluate the mod. 
if ((d != 0) && (n % d) == 0) 
    Console.Writeline(d + " is a factor of " + n); 

Answer 6

Raccomando questo articolo da Dotnet Mob: http://dotnetmob.com/csharp-article/short-circuit-evaluation-in-c/

- & & è corto-circuito operatore logico

cercare e operazioni se uno degli operandi è risultata falsa espressione poi totale valutata a false, quindi non è necessario valutare le espressioni rimanenti, analogamente in operazione OR se si può saltare un qualsiasi degli operandi valutati a true, quindi la valutazione rimanente

- & L'operatore può essere utilizzato come operatore unario o binario. cioè, unario & può essere utilizzato per ottenere l'indirizzo del suo operando in un contesto non sicuro.

Answer 7

Secondo - C# 4.0 Il riferimento completo da Herbert Schildt

& - operatore logico AND
| - operatore logico OR

& & - in corto circuito e l'operatore
|| - Corto circuito o Operatore

Un semplice esempio può aiutare a capire il fenomeno

using System; 

class SCops { 
    static void Main() { 
     int n, d; 
     n = 10; 
     d = 2; 

     if(d != 0 && (n % d) == 0) 
      Console.WriteLine(d + " is a factor of " + n); 
     d = 0; // now, set d to zero 

     // Since d is zero, the second operand is not evaluated. 
     if(d != 0 && (n % d) == 0) 
      Console.WriteLine(d + " is a factor of " + n); 
     // Now, try the same thing without the short-circuit operator. 
     // This will cause a divide-by-zero error. 
     if(d != 0 & (n % d) == 0) 
      Console.WriteLine(d + " is a factor of " + n); 
    } 
} 

Qui i & operatore controlla ogni operando e & & controlla solo il primo operando.

Come si può notare per operazioni 'AND' qualsiasi operando che è falso valuterà l'intera espressione su falso indipendentemente da qualsiasi altro valore di operandi nell'espressione. Questo modulo in cortocircuito aiuta a valutare la prima parte ed è abbastanza intelligente da sapere se la seconda parte sarà necessaria.

L'esecuzione del programma genera un errore di divisione per zero dell'ultima condizione if in cui entrambi gli operandi sono controllati per l'operatore & e non viene eseguita alcuna gestione delle eccezioni per affrontare il fatto che 'd' può essere 0 in qualsiasi momento di tempo.

Lo stesso caso si applica a '|' in C#.

Questo è leggermente diverso da C o C++ dove "&" e "|" erano operatori AND bit e OR bit. Tuttavia C# applica anche la natura bit a bit di & e | solo per le variabili int.