C中的二进制到字符？

Question

I have an array

bin =

     0     1     1     0     0     0     0     1
     0     1     1     0     0     1     0     1
     0     1     1     1     0     0     1     0
     0     1     1     1     0     0     1     1
     0     1     1     0     0     1     1     1
     0     1     1     0     1     0     1     0
     0     1     1     0     1     0     0     0
     0     1     1     0     0     0     0     1
     0     1     1     1     0     1     0     0
     0     0     1     0     0     1     1     1
     0     1     0     0     1     0     1     0
     0     1     0     0     1     0     0     0

Every line in the array is a 8 bits binary letter

bin is equivalent to this string aersgjhat'JH

This is very simple using matlab, but I couldn't find how to convert a table full of binary 8 bit words to a string in C.

Answer 1

You really need to read in each byte of the array - I'm assuming a '0' is no bit set and '1' is bit set ...

A loop that sets each bit would probably do the job - if I'm reading your array correctly ....

unsigned char bin[] = {....}   // your array full of data
unsigned char output[ 16 ]      // you will need to set the output size...
int nIndex = 0;
int nOutIndex = 0;
....

// the inner loop ...
output[ nOutIndex ] = 0;
for( nIndex = 0; nIndex < 8; nIndex++ )
{
    if ( bin[ nIndex ] == 1 )
       output[ nOutIndex ] |= 1;

    output[ nOutIndex ] <<= 1;
}    

This example shows a simple method for setting the bit and shifting. Please note this is only the inner loop, and there's no code for moving through the bin array (from the second char onwards.

Answer 2

It is unimportant what is the type of the bin . It may be some integer type. For the demonstrative purpose I used type uint8_t . You can use for example type int .

The program can look the following way

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

int main( void )
{
    uint8_t bin[][8] =
    {    
        { 0, 1, 1, 0, 0, 0, 0, 1 },
        { 0, 1, 1, 0, 0, 1, 0, 1 },
        { 0, 1, 1, 1, 0, 0, 1, 0 },
        { 0, 1, 1, 1, 0, 0, 1, 1 },
        { 0, 1, 1, 0, 0, 1, 1, 1 },
        { 0, 1, 1, 0, 1, 0, 1, 0 },
        { 0, 1, 1, 0, 1, 0, 0, 0 },
        { 0, 1, 1, 0, 0, 0, 0, 1 },
        { 0, 1, 1, 1, 0, 1, 0, 0 },
        { 0, 0, 1, 0, 0, 1, 1, 1 },
        { 0, 1, 0, 0, 1, 0, 1, 0 },
        { 0, 1, 0, 0, 1, 0, 0, 0 },
    };

    const size_t N = sizeof( bin ) / sizeof( *bin ); 
    char s[N + 1] = { '\0' };

    for ( size_t i = 0; i < N; i++ )
    {
        for ( size_t j = 0; j < 8; j++  )
        {
            s[i] = ( ( unsigned char )s[i] << 1 ) | ( bin[i][j] & 1 );
        }
    }

    puts( s );
}    

The program output is

aersgjhat'JH

Answer 3

Get a value_so_far initialized to 0

int value_so_far = 0;

Read a bit, multiply the value_so_far by 2 and add that bit

int bit;
if (scanf("%d", &bit) != 1) /* error */;
if (bit < 0 || bit > 1) /* error */;
value_so_far *= 2;
value_so_far += bit;

After 8 times, you have an 8-bit value.
Restart.