Olá,
Eu utilizo o Visual Studio .NET para programar em C/C++. Estou iniciando no mundo da programação em C++. Me deparei com um símbolo “^” antes de algumas variáveis. Eu gostaria de saber qual a função desse símbolo? Desde já obrigado!
1 curtida
É o operador de bits XOR. Ó:
Há um operador um pouco raro em C++ chamado EXCLUSIVE OR (ou exclusivo) também conhecido por XOR (em inglês se pronuncia “equis-or”). Este operador é escrito com o símbolo do acento circunflexo ^. O resultado desta operação é 1 se os dois bits de entrada forem diferentes, caso contrário retorna 0:
0 0 1 1 operando1
0 1 0 1 operando2
----------
0 1 1 0 (operando1 ^ operando2) - resultado de retorno
Um simples código de exemplo:
int x = 12; // binario: 1100
int y = 10; // binario: 1010
int z = x ^ y; // binario: 0110, or decimal 6
O operador XOR é freqüentemente utilizado para inverter alguns dos bits de uma expressão inteira. Na máscara deste operador se há um 1 o bit correspondente é invertido, se há um zero o bit é mantido como está. Abaixo há um programa para piscar o pino digital 5.
// Piscar_Pino_5
// demonstração para o Exclusive OR
void setup(){
DDRD = DDRD | B00100000; // marca o pino digital 5 como saida.
Serial.begin(9600);
}
void loop(){
PORTD = PORTD ^ B00100000; // inverte o bit 5 (digital pino 5), mantem os demais intocados.
delay(100);
}
PS: Faltou a fonte, rs!
3 curtidas
Vale a pena frisar que é o operador binário xor, não é o xor lógico.
Por exemplo,
if(funcao_a() ^ funcao_b()) {
std::cout << "entrou\n";
}
vai imprimir o “entrou” em alguns casos em que ambas essas funções retornarem alguns valores que não sejam zero. Mesmo que “não zero” seja considerado um valor verdadeiro para o if, e um xor lógico retornasse falso caso ambos fossem diferente de zero, com o xor bitwise não acontece sempre isso pois vai executar bit a bit e converter de acordo o valor resultante para booleano.
No meu caso mais especificamente eu estou me deparando com essa situação:
System::string ^nome = txtNome.Text;Quando eu removo o “^” dá erro de incompatibilidade de tipos.
Não existe diferença entre os dois. O operador xor retorna true (1) para bits dos operandos diferentes e false (0) para bits iguais.
O que você chama de “xor lógico” é só o xor entre 0s e 1s, e não com qualquer número.
Vai imprimir “entrou” em todos os casos onde os valores das duas funções forem diferentes.
Parece que o que você está se referindo é um ponteiro gerenciado. É a mesma coisa de um ponteiro normal, mas é o runtime que toma conta de liberar a memória quando você perder a referência pra ele. É um ponteiro que aponta para um objeto na memória que está numa heap que é garbage collected (como é no Java).
Tem exemplos aqui.
1 curtida
Compreendi. Mas porque o compilador aponta como erro de conversão de tipos quando eu removo o ^?
Porque o ^ faz parte do tipo, e o tipo de txtNome.Text tem ^.
Obrigado por todos os comentários.
Isso não é valido para tipos não booleanos, como citei acima.
#include <iostream>
using namespace std;
int main() {
int A = 1;
int B = 2;
if (A) {
std::cout << "A é considerado: true\n";
} else {
std:: cout << "A é considerado false\n";
}
if (B) {
std::cout << "B é considerado: true\n";
} else {
std:: cout << "B é considerado false\n";
}
if (A ^ B) {
std::cout << "A bitwise-xor B é considerado true\n";
} else {
std:: cout << "A bitwise-xor B é considerado false\n";
}
if (!(A) != !(B)) {
std::cout << "A xor B é considerado true\n";
} else {
std:: cout << "A xor B é considerado false\n";
}
return 0;
}
Saída:
A é considerado: true
B é considerado: true
A bitwise-xor B é considerado true
A xor B é considerado false
Se A e B são considerados true, o resultado do xor lógico deve ser false.
Mas A bitwise-xor B é avaliado como true.
Pois não atende a tabela verdade pro xor:
O operador ! transforma 2 (ou qualquer número maior que 0) em 0 porque porque ele faz um cast de inteiro para boolean antes de fazer a negação.
Você não está comparando os inversos de A e B, mas 0 com 0. O cast de inteiro para boolean destrói informação.
O que eu disse no outro post foi que os operadores “lógicos” (entre aspas porque os bitwise também são lógicos) são apenas um subset dos bitwise, onde podemos usar apenas 0 e 1 para ter a mesma semântica. Se usar números diferentes, informação vai ser descartada.
Eu não me referia a especificidade da implementação em C++, estava falando de teoria. Em C++ (e provavelmente em várias outras linguagens) existe diferença por causa do cast implícito.
Eu não falei que estava 
Só mostrei como não é equivalente ao xor comum dada a forma como os demais valores são tratados como booleanos o que é comum em casos como retornos de funções.
Se A é considerado true e B também, então se A ^ B deveria ser falso, mas não é por ser bit a bit. Por isso sim é relevante a diferença. Só isso.