Fazia um bom tempo que não Postava nada neste fórum. Pois Bem vou postar um tutorial explicando como criar uma função para converter valores ANSI que representam um inteiro para sua representação decimal.

Operações Bitwise

No caso de você não saber o que é uma operação bitwise e nunca ter ouvido falar em Álgebra de Boole, vou dar uma rápida explicação do que são e como aplicar em C.

Uma operação bitwise é uma operação que aplica operações básicas booleanas sobre bits individuais. Como sabe, computadores normalmente operam sobre bytes inteiros, no mínimo. No entanto as vezes precisamos "ligar" e "desligar" bits individuais(como precisaremos a seguir) para manipular um dado valor. Linguagens de programação normalmente oferecem operadores para executar essas operações. Essas operações básicas são chamadas "AND", "OR" e "XOR". Você talvez conheça como conjunção, disjunção e complemento, respectivamente.

Enquanto uma operação booleana v(leia "ou") ou ^(leia 'e') opera sobre todo o cálculo, operações bitwise operam sobre bits individuais de um valor completo. Por exemplo, peguemos a seguinte operação a ^ b(a E b), onde a é 1(verdadeiro) e b é 0(falso). O resultado será 0(falso). Isso foi uma operação booleana. Para entender o por que do resultado, vamos entender como cada operação funciona:

A operação ^(AND) resultará em verdadeiro(estamos usando V aqui para representar verdadeiro, mas note que podemos usar qualquer coisa) apenas se ambos os valores forem verdadeiros, caso contrário será falso. Nesse caso podemos resumir para o seguinte:

F ^ F == F
F ^ V == F
V ^ F == F
V ^ V == V

Temos também a operação v(OR), que resulta em verdadeiro caso ambos ou pelo menos um dos valores seja verdadeiro, caso contrário é falso. Resumiremos assim:

F v F == F
V v F == V
F v V == V
V v V == V

Finalmente temos a operação XOR(usaremos +), ou "ou exclusivo", que resulta em verdadeiro apenas se um dos valores for verdadeiro, mas não ambos. Segue uma tabela:

F + F == F
F + V == V
V + F == V
V + V == F

Temos também a operação NOT(usaremos ¬ para representá-la), ou "negativação". O valor é invertido. Por exemplo, ¬V == F e ¬(¬V) == V.

Finalmente podemos construir operações derivadas através dessas operações básicas. Como exemplo:

¬(a v b) ^ a

Isso é extremamente simples. Se a == V e B == F, temos: ¬(V v F) ^ V. Vamos calcular rápido:

¬(V) ^ V
F ^ V
F

Não há segredo, isso é tudo que precisa entender para efetuar a conversão. Essas operações são extremamente simples e eu ficaria impressionado se ainda não conhecesse(mesmo que não programe). Mesmo assim, aí está uma explicação rápida das operações booleanas básicas.

Finalmente, uma operação bitwise é um cálculo booleano efetuado sobre cada bit de um valor. Um byte é composto por 8 bits, e cada bit pode ter apenas 2 valores. Isso, percebeu a semelhança? Vamos efetuar a operação "AND" sobre dois valores inteiros. Vamos pegar 5 e 9. Na memória seriam representados assim(Little Endian):

00000101b(5d) e 00001001b(9d)

Agora vamos efetuar a operação bitwise AND(representada em C por &):

00000101 & 00001001 == 00000001(1d)

Se efetuarmos a operação bitwise OR(representada por |), teríamos:

00000101 | 00001001 == 00001101(13d)

Agora vamos escrever tudo isso em C:

#include <stdio.h>

int main()
{
    unsigned int a = 5, b = 9;
    
    printf("a & b == %u\na | b == %d", a & b, a | b);
    
    getchar();
    return 0;
}

Compile e perceba que o output é exatamente o que prevemos acima.