¿Qué significa "variable | variable" en C++?

Question

que estaba buscando en el código de demostración temporizador ITE8712 organismo de control cuando vi esto:

void InitWD(char cSetWatchDogUnit, char cSetTriggerSignal) 
{ 
OpenIoConfig();  //open super IO of configuration for Super I/O 

SelectIoDevice(0x07); //select device7 

//set watch dog counter of unit 
WriteIoCR(0x72, cSetWatchDogUnit|cSetTriggerSignal); 

//CloseIoConfig();  //close super IO of configuration for Super I/O 
} 

y, me pregunto qué se entiende por esta línea:

cSetWatchDogUnit|cSetTriggerSignal 

porque la función WriteIoCR se ve así:

void WriteIoCR(char cIndex, char cData) 
{ 
//super IO of index port for Super I/O 
//select super IO of index register for Super I/O 
outportb(equIndexPort,cIndex); 

//super IO of data for Super I/O 
//write data to data register 
outportb(equDataPort,cData); 
} 

Así CINDEX debe ser 0x72, pero ¿y el cData? Realmente no entiendo el "|" ya que solo lo he usado para O ("||") en una declaración condicional.

Answer 1

Es una nivel de bits, a diferencia de su or lógico normal. Básicamente establece los bits en la variable objetivo si se estableció el bit correspondiente en cualquiera de las variables de origen.

Por ejemplo, la expresión 43 | 17 se puede calcular como:

43 = 0x2b = binary 0010 1011 
17 = 0x11 = binary 0001 0001 
        ==== ==== 
     "or" them: 0011 1011 = 0x3b = 59 

Ver this answer para un examen más a fondo de los distintos operadores de bits.

Se usa normalmente cuando se quieren manipular bits específicos dentro de un tipo de datos, como el control de un temporizador de vigilancia en un sistema integrado (su caso de uso particular).

Puede utilizar or (|) para convertir los bits dentro y and (&) para apagarlos (con la inversión de la máscara de bits que se utiliza para convertirlos en

Así, para encender la b3 bits, utilice:.

val = val | 0x08; // 0000 1000 

Para desactivarla, utilice:

val = val & 0xf7; // 1111 0111 

para detectar si b3 está configurado actualmente, utilice:

if ((val & 0x08) != 0) { 
    // it is set. 
} 

Usted normalmente ve las máscaras de bits algo definido como:

#define B0 0x01 
#define B1 0x02 
#define B2 0x04 
#define B3 0x08 
#define B4 0x10 

o:

enum BitMask { 
    B0 = 0x01, 
    B1 = 0x02, 
    B2 = 0x04, 
    B3 = 0x08, 
    B4 = 0x10 
}; 

En cuanto a lo que esto significa:

WriteIoCR (0x72, cSetWatchDogUnit|cSetTriggerSignal); 

Es más que probable , 0x72 será un puerto de E/S o de algún tipo en el que esté escribiendo y cSetWatchDogUnit y cSetTriggerSignal serán máscaras de bits que combine para generar el comando (configure la señal de disparo y use un valor unitario para el perro guardián). Lo que ese comando significa en la práctica puede inferirse, pero es más seguro al referirse a la documentación del circuito de vigilancia.

Y, en la remota posibilidad de que usted no sabe lo que es un circuito de vigilancia es para, es un circuito simple que, si no una patada con la suficiente frecuencia (con otro comando ), lo hará reinicie su sistema, probablemente activando el pin de reinicio en cualquier procesador que esté usando.

Es una forma de detectar el comportamiento incorrecto del software automáticamente y devolver un dispositivo a un estado inicial conocido, suscribiéndose a la teoría de que es mejor reiniciar que continuar ejecutándose mal.

Answer 2

Esa es una bitwise or. Se usa aquí para combinar banderas.

Answer 3

x | y se utiliza generalmente con Plain Old Datas en C/C++. Significa bitwise O.

p. Ej.

char x = 0x1, y = 0x2; 
x | y ==> 0x3 

[Nota: operator | puede sobrecargarse para class/struct de acuerdo a su necesidad.]

Answer 4

| es un bit a bit o. Activa o desactiva los bits (1 en lugar de 0) si uno u otro del mismo bit en cualquiera de los enteros está activado.

|| es lógica o. Devuelve verdadero si uno u otro son verdaderos.

Answer 5

OK, aquí está por qué utiliza un bit a bit o, o los ve, en este tipo de situación.

Muchas veces, estas variables son las banderas que se utilizan para empacar múltiples piezas de datos en un solo carbón

Si cSetWatchDogUnit y cSetTriggerSignal

tienen los bits que no se superponen (imaginar cSetWatchDogUnit = 1 << 0 y cSetTriggerSignal = 1 << 1 puede comprobar más tarde para ver si se fijan con un nivel de bits y, como en este ejemplo artificial:

if cData & cSetWatchDogUnit 
    do something 
if cData & cSetTriggerSignal 
    do something else 

Durante todo el tiempo, estas dos fla Los gs pueden empaquetarse y pasarse en un solo char. De esta forma, no terminará pasando una matriz de bools, puede agregar nuevas constantes cSetSomeOtherDamnfoolThing = 1 << 2 y puede hacer referencia a indicadores como variables en su código.