Como transferir valores binários em c de programação

A linguagem de programação C possui dois operadores binários que realizam a operação equivalente a “Todos mover um passo para a esquerda (ou direita).” A lt; lt; e gt; gt; operadores mudar os bits em valor, marchando-los para a esquerda ou direita, respectivamente. Aqui está o formato para o lt; lt; operador:

v = int lt; lt; contagem-

int é um valor inteiro. contagem é o número de lugares para deslocar os bits do valor para a esquerda. O resultado desta operação é armazenado na variável v. Qualquer bits que são deslocadas para a esquerda para além da largura do int variável X estão perdidos. Novos bits deslocados pela direita são sempre 0.

Como com a maioria absurdo binário, que ajuda a visualmente ver o que está acontecendo em um valor quando os seus bits são deslocados.

Todos para fora da piscina!

#include char * binbin (int n) -int main () {int bshift, x-printf ("Digite um valor de 0 a 255: ") -scanf ("% d",&bshift) -para (x = 0-xlt; 8-x ++) {printf ("% sn", Binbin (bshift)) - bshift = bshift lt; lt; 1-} retorno (0) -} char * binbin (int n) {bin static char [9] -int x-para (x = 0-xlt; 8-x ++) {bin [x] n = & 0x80? `1`: `0`-n lt; lt; = 1-} bin [x] = `` -Retornar (bin) -}

A operação de deslocamento ocorre na Linha 15 em Todos para fora da piscina !. O valor na variável bshift é deslocado para o bit esquerda.

Exercício 1: Digite o código-fonte de todos fora da piscina! em seu editor e construir um novo projeto.

O efeito líquido de uma mudança pouco à esquerda é dobrar um valor. Isso vale até um certo ponto: Obviamente, quanto mais te deixou mudar, alguns pedaços se perder eo valor deixa dobrar. Além disso, este truque só funciona para valores não assinados.

exercício 2: Modificar o código fonte de todos fora da piscina! para que a função printf () na Linha 14 também exibe o valor decimal da bshift variável. Você também deve modificar a função binbin () para que ele exibe 16 dígitos em vez de 8.

Aqui está a saída ao usar o valor 12:

Digite um valor de 0 a 255: 120000000000001100 120000000000011000 240000000000110000 480000000001100000 960000000011000000 1920000000110000000 3840000001100000000 7680000011000000000 1536

Tente o valor 800.000.000 (não digite as vírgulas) para ver como a regra de duplicação falhar como os valores de manter deslocando para a esquerda. Também ver a barra lateral vizinha “números binários negativos.”

o gt; gt; operador de deslocamento funciona de forma semelhante ao lt; lt; mudar de operador, embora os valores são marcharam para a direita em vez da esquerda. Qualquer pouco desse marcharam para fora da extremidade direita é descartado, e são inseridos apenas bits zero no lado esquerdo. Aqui é o formato:

v = int gt; gt; contagem-

int é um valor inteiro, e contagem é o número de lugares para mudar os bits para a direita. O resultado é armazenado na variável v.

exercício 3: Modificar o código fonte do Exercício 2, para que o operador de deslocamento à direita é usado em vez do desvio para a esquerda na Linha 15. Construir o programa.

Aqui está o resultado quando se utiliza o valor de 128:

Digite um valor de 0 a 255: 1280000000010000000 1280000000001000000 640000000000100000 320000000000010000 160000000000001000 80000000000000100 40000000000000010 20000000000000001 1

ao contrário do lt; lt; operador, o gt; gt; é garantido para sempre reduzir o valor pela metade quando você mudar um dígito para a direita. Na verdade, a gt; gt; operador é muito mais rápido para utilizar em um valor inteiro do que o operador / (divisão) para dividir um valor de 2.

o lt; lt; e gt; gt; operadores estão disponíveis apenas na língua C. Em C ++, operadores semelhantes são usados para receber entrada padrão e enviar a saída de padrão.

Os números binários são sempre positivos, considerando que os valores de um bit pode ser apenas 1 ou 0 e não -1 e 0. Então como é que o computador fazer assinado inteiros? Fácil: Ele engana.

O bit mais à esquerda em um valor binário assinado é conhecido como o bit de sinal. Quando esse bit é definido (igual a 1), o valor é negativo para um int assinado. Caso contrário, o valor é lido como positivo.

Neste exemplo, o bit de sinal está definido para um char assinado. Os valores expressos são negativos, que está na gama de uma variável caractere assinado.

Neste exemplo, o bit de sinal é ignorado porque o valor é um unsigned char. Os valores só pode ser positivo, razão pela qual a faixa positiva para uma variável não assinada é maior do que para uma variável assinado.