записать двоичную строку как двоичную в файл

Используйте escape-последовательности внутри строкового литерала для обозначения байтов 0x00 и 0x01, а не символов 0 и 1:

char s[] = "\x00\x01";

используйте байтовый тип, а не char, и удалите эту строку, конечно, она показывает 0x30 для 0, вы попросили ее написать «0», а не 0 .... вы можете указать двоичный код, используя b byte b1 = 10001110b; конечно, вы не можете сделать из него массив, если вам нужны более длинные числа, вам придется писать их один за другим или написать метод\функцию для разбора двоичных строк для вас, если он не существует в открытом исходном коде уже.

Если вы пытаетесь выразить строку «011000100110100101110100» в виде трех байтовых значений 98, 105, 116, вам сначала нужно преобразовать их из массива символов (или «строки», как это называется в C) в массив числовых значений. .

Что-то вроде этого может быть хорошим началом:

unsigned char *convert(char *input)
{
  int len = strlen(input);
  /* Can only correctly handle strings that have 'full' bytes */
  unsigned char *rv = malloc(len/8); 
  char *cp;
  unsigned char *dp = rv;;
  char dp_inc = 0;

  for (cp = input; *cp; cp++) {
    *dp = ((*dp) << 1) | (*cp == '1');
    if ((++dp_inc) >= 8) {
      dp_inc = 0;
      dp++;
    } 
  }

  return rv;
}

Эта процедура проходит через входную строку и преобразует ее в двоичные числа, которые она представляет. Вероятно, это может быть связано с некоторой уборкой, поскольку это не обязательно образец читаемого кода и, вероятно, должен возвращать количество выделенных байтов и принимать ограничитель диапазона вместо того, чтобы полагаться на strlen.

Хорошо, вот ваше решение (хотя оно не очень тщательно проверено):

template<typename TItem, typename TItem2>
void SetEnableFlags(TItem &BitFlags, const TItem2 &Flags)
{
    BitFlags = (BitFlags|Flags);
}

const unsigned char CharArrayToByte(const char Data[])
{
    if(Data == NULL){return 0;}
    if(strlen(Data) < 8){return 0;}
    unsigned char Byte = 0;
    SetEnableFlags(Byte,(Data[0]-'0')*128);
    SetEnableFlags(Byte,(Data[1]-'0')*64);
    SetEnableFlags(Byte,(Data[2]-'0')*32);
    SetEnableFlags(Byte,(Data[3]-'0')*16);
    SetEnableFlags(Byte,(Data[4]-'0')*8);
    SetEnableFlags(Byte,(Data[5]-'0')*4);
    SetEnableFlags(Byte,(Data[6]-'0')*2);
    SetEnableFlags(Byte,(Data[7]-'0')*1);
    return Byte;
}

const bool ConvertToBytes(char Bytes[], const char Binary[])
{
    if( (Binary == NULL) || (Bytes == NULL) ){return false;}

    //Checks it's a power of 8
    int Size = strlen(Binary);
    if(Size < 8){return false;}
    float SizeTest = ((float)Size/8.0);
    if( (SizeTest - (int)SizeTest ) != 0.0 ){return false;}

    unsigned int Power = 0;
    unsigned int Iter = 0;
    do
    {
        Power = 8*Iter;
        Bytes[Iter] = CharArrayToByte( (Binary+Power)  );
        Iter++;
    }while(Power < Size);
    return true;
}

int main()
{
    char Bytes[3]; //Allocate enough space for it
    char Binary[] = "000000010000001100001111"; //1, 3, 15
    if(!ConvertToBytes(Bytes,Binary)){return 1;}

    printf("%d %d %d!\n",Bytes[0],Bytes[1],Bytes[2]);

    return 0;
}

Вы также можете прочитать эту тему здесь чтобы облегчить вашу работу.

Код не оптимизирован. Вы можете использовать его для любых целей, даже коммерческих (если вы можете его продать). Строки станут нечитаемыми за пределами 8 бит, поэтому вы можете просто вызвать CharArrayToByte вручную (убедитесь, что длина массива символов действительно составляет 8 символов, иначе у вас возникнут проблемы). Если вы хотите преобразовать его обратно, это вопрос обратного процесса.

Неясно, используете ли вы C или C++ (с кодированием C), поэтому вам, вероятно, придется изменить его в соответствии с вашими потребностями.