Convertendo um número inteiro não assinado para binário em C

Com a versão atual do C (C23), use"%b"

char result[ARRAY_SIZE];
// convertWholeNumberToBinary(294, result); 
snprintf(buf, sizeof result, "%b", 294);

Você está cometendo alguns erros, mas o maior é quando você inverte seu array char. Você está passando, ARRAY_SIZEmas o array não foi totalmente preenchido porque não podemos inserir um inteiro de 99 bits, então ainda há valores indeterminados no final do array que são trocados para a frente dele. Se o último caractere no final do array for apenas um, '\0'você agora tem uma string vazia terminada em nulo para imprimir.

Em vez disso, você deseja passar i, que indica o comprimento real da string no final do loop.

Você também está adicionando 1ou 0à string, em vez do equivalente char.

Terceiro, você não está inicializando seu array char em mainentão seu conteúdo é indeterminado. Agora, já que suas outras funções não terminam explicitamente a string com null, você entra em território de comportamento indefinido ao imprimi-la como uma string. Solução simples: inicialize esse array char com "", o que pode não funcionar se isso for compilado com um compilador C (vs. C++).

Alternativamente, basta inserir o terminador nulo em convertWholeNumberToBinary.

#include <stdio.h>

const int ARRAY_SIZE = 100;

void reverseCharArray(char *x, int len) {
    for (int end = len - 1, beg = 0; beg < end; end--, beg++) {
        char temp = x[beg];
        x[beg] = x[end];
        x[end] = temp;
    }
}

void convertWholeNumberToBinary(unsigned int x, char *result) {
    int i = 0;
    while (x != 0) {
        result[i++] = '0' + (x % 2);
        x /= 2;
    }

    result[i] = '\0';
    reverseCharArray(result, i);
}

int main() {
    char result[ARRAY_SIZE];
    convertWholeNumberToBinary(294, result); 
    printf("%s\n", result);
    return 0;
}

A solução será mais simples (e rápida) se o resultado for escrito diretamente no buffer na ordem correta para evitar a necessidade de inverter a string.

Certamente, não sabemos o tamanho do resultado antecipadamente, mas podemos escrever o buffer do final para baixo e então exibir apenas a parte que foi escrita.

Ao escrever cada dígito, ele precisa ser convertido de seu valor numérico (0 ou 1) para o caractere ASCII ('0' ou '1') para exibição. Isso pode ser feito adicionando '0' (o caractere ASCII '0' tem o valor numérico 48).

Como esse método funciona enquanto o dígito estiver no intervalo de 0 a 9, é bastante simples generalizar a função para converter números para qualquer base no intervalo de 2 a 10.

Em suma, isso pode ser implementado da seguinte forma:

#include <stdio.h>

// "base" must be 2-10 
// "bufferPos" must be the size of the given buffer
char *unsignedToString(unsigned n, char *buffer, size_t bufferPos, unsigned base)
{
    bufferPos--;
    buffer[bufferPos] = 0;  // Null termination
    do   // Use a do-while loop so that at least one digit is printed even if n is 0
    {
        bufferPos--;
        buffer[bufferPos] = (n % base) + '0';
        n = n / base;
    } while (n != 0 && bufferPos != 0);  // Stop if there are no more non-zero digits or we are going beyond the beginning of the buffer
    return buffer + bufferPos;  // Return a pointer to the location in the buffer where the string begins
}

int main()
{
    char str[100];  // Max string length is 99
    unsigned n = 294, base = 2;
    char *result = unsignedToString(n, str, sizeof(str), base);
    printf("%u in base %u = %s\n", n, base, result);
}

Além do que já foi dito, talvez como iniciante não pense muito nisso, mas comece com algo mais fácil, como uma rotina traduzindo um inteiro de largura fixa para a string binária correspondente. Então você sabe o tamanho exato. Não há necessidade de divisão ou reversão do array também. Apenas mascare um dígito binário por vez, então insira os caracteres no array do fim de volta para o começo. Exemplo:

#include <stdio.h>
#include <stdint.h>

void int32_to_binstr (uint32_t x, char *result) 
{
  for(size_t i=0; i<32; i++)
  {
    size_t index = 32 - i - 1;  // insert starting from the end of the string
    
    if(x & (1u << i))           // 1u << i creates a bit mask
      result[index] = '1';      // if the bit was set add an ASCII '1'
    else
      result[index] = '0';      // otherwise add an ASCII '0'
  }
  result[32] = '\0';            // nul terminate explicitly
}

int main() {
    char result[32+1];
    int32_to_binstr(294, result);
    puts(result);
    return 0;
}

Saída:

00000000000000000000000100100110

Este é o exemplo mais fundamental: se você entender esse código, entenderá a maior parte do que é valioso tirar do exercício.

Mas é claro que a partir daqui você pode tornar esse código mais avançado, como mascarar zeros à esquerda, oferecer suporte a diferentes tamanhos binários, imprimir dígitos com espaços entre cada nibble/byte, etc.