Как читать кусок памяти как char в C ++

Question

Здравствуйте, у меня есть кусок памяти (выделенный с помощью malloc ()), который содержит биты (битовые литералы), я хотел бы прочитать его как массив символов или, лучше, я бы хотел распечатать ASCII значение 8 последовательных битов памяти.

Я выделил ему память как char *, но я не смог вывести символы лучше, чем вычислять каждый бит, добавляя значение в char и сдвигая влево значение char в цикле , но я искал более быстрое решение. Спасибо

На данный момент я написал следующее:

для выделения:

char * bits = (char*) malloc(1);

для записи в mem:

ifstream cleartext;
cleartext.open(sometext);
while(cleartext.good())
{
     c = cleartext.get();
     for(int j = 0; j < 8; j++)
     {  //set(index) and reset(index) set or reset the bit at bits[i]
        (c & 0x80) ? (set(index)):(reset(index));//(*ptr++ = '1'):(*ptr++='0');
         c = c << 1;
     }..
}..

и до сих пор я не смог вернуть символ, я только распечатал биты, используя:

printf("%s\n" bits);

Пример того, что я пытаюсь сделать:

input.txt содержит строку «AAAB»

Моя программа должна записать «AAAB» как «01000001010000010100000101000010» в память (это значения ASCII в битах AAAB, которые составляют 65656566 в битах)

Тогда я бы хотел, чтобы в нем была функция перезаписи содержимого памяти в файл.

Таким образом, если в памяти снова содержится «01000001010000010100000101000010», она будет записывать в выходной файл «AAAB».

Answer 1

Я бы хотел распечатать значение ASCII из 8 последовательных битов памяти.

Возможное значение для любого бита: 0 или 1. Возможно, вам нужен хотя бы байт.

char * bits = (char *) malloc (1);

Выделяет 1 байт в куче. Гораздо более эффективным и беспроблемным было бы создание объекта в стеке, т. Е .:

char bits; // a single character, has CHAR_BIT bits

ifstream cleartext;

cleartext.open (SOMETEXT);

Вышесказанное ничего не пишет в mem. Он пытается открыть файл в режиме ввода.

У него есть символы ascii и обычные eof or \ n, или что-то в этом роде, ввод будет только текстовым файлом, поэтому я думаю, что он должен содержать только символы ASCII, поправьте меня, если я ошибаюсь.

Если в вашем файле есть только ASCII-данные, вам не о чем беспокоиться. Все, что вам нужно сделать, это прочитать содержимое файла и записать его. Компилятор управляет тем, как будут храниться данные (т. Е. Какую кодировку использовать для ваших символов и как представлять их в двоичном виде, порядковый номер системы и т. Д.). Самый простой способ чтения / записи файлов будет:

// include these on as-needed basis
#include <algorithm>
#include <iostream>
#include <iterator>
#include <fstream>

using namespace std;
// ...

/* read from standard input and write to standard output */
copy((istream_iterator<char>(cin)), (istream_iterator<char>()),
                  (ostream_iterator<char>(cout)));
/*-------------------------------------------------------------*/

/* read from standard input and write to text file */
copy(istream_iterator<char>(cin), istream_iterator<char>(),
         ostream_iterator<char>(ofstream("output.txt"), "\n") );
/*-------------------------------------------------------------*/

/* read from text file and write to text file */
copy(istream_iterator<char>(ifstream("input.txt")), istream_iterator<char>(),
         ostream_iterator<char>(ofstream("output.txt"), "\n") );
/*-------------------------------------------------------------*/

Последний оставшийся вопрос: хотите ли вы что-то сделать с двоичным представлением? Если нет, забудь об этом. Иначе, обновите ваш вопрос еще раз.

Например: обработка массива символов для его шифрования с использованием блочного шифра

/* a hash calculator */
struct hash_sha1 {
 unsigned char operator()(unsigned char x) {
    // process
    return rc;
  }
};

/* store house of characters, could've been a vector as well */
basic_string<unsigned char> line;

/* read from text file and write to a string of unsigned chars */   
copy(istream_iterator<unsigned char>(ifstream("input.txt")),
                                     istream_iterator<char>(),
                                      back_inserter(line) );

/* Calculate a SHA-1 hash of the input */   
basic_string<unsigned char> hashmsg;
transform(line.begin(), line.end(), back_inserter(hashmsg), hash_sha1());

Answer 2

int numBytes = 512;
char *pChar = (char *)malloc(numBytes);
for( int i = 0; i < numBytes; i++ ){
   pChar[i] = '8';
}

Поскольку это C ++, вы также можете использовать «new»:

int numBytes = 512;
char *pChar = new char[numBytes];
for( int i = 0; i < numBytes; i++ ){
   pChar[i] = '8';
}

Answer 3

Если вы хотите посетить каждый бит в блоке памяти, похоже, вам нужно std::bitset.

char* pChunk = malloc( n );
// read in pChunk data

// iterate over all the bits.
for( int i = 0; i != n; ++i ){
    std::bitset<8>& bits = *reinterpret_cast< std::bitset<8>* >( pByte );
    for( int iBit = 0; iBit != 8; ++iBit ) {
        std::cout << bits[i];
    }
}

Answer 4

Я не уверен, что полностью понимаю, что вы пытаетесь сделать, но пара предложений:

1) используйте std :: vector вместо malloc / free и new / delete. Это безопаснее и не требует много накладных расходов.

2) при обработке попробуйте делать куски, а не байты. Несмотря на то, что потоки буферизуются, обычно более эффективно захватывать порцию за раз.

3) есть много разных способов вывода битов, но опять же вы не хотите выводить поток для каждого символа. Возможно, вы захотите попробовать что-то вроде следующего:

void outputbits(char *dest, char source)
{
    dest[8] = 0;
    for(int i=0; i<8; ++i)
        dest[i] = source & (1<<(7-i)) ? '1':'0';
}

Передайте ему буфер вывода char [9] и ввод char, и вы получите распечатанную последовательность битов. Достойные компиляторы выдают нормальный выходной код для этого ... сколько скорости вам нужно?

Answer 5

Вы спрашиваете, как скопировать байты памяти произвольной структуры в массив char *? Если так, то это должно сработать

SomeType t = GetSomeType();
char* ptr = malloc(sizeof(SomeType));
if ( !ptr ) {
  // Handle no memory.  Probably should just crash
}
memcpy(ptr,&t,sizeof(SomeType));

Answer 6

Не могли бы вы объяснить более подробно, возможно, включая код? То, что вы говорите, не имеет смысла, если я полностью не прочитал ваш вопрос. Вы делаете что-то подобное?

char * chunk = (char *)malloc(256);

Если это так, вы можете получить доступ к данным любого символа, обрабатывая chunk как массив: chunk[5] дает вам 5-й элемент и т. Д. Конечно, это будут символы, которые могут быть теми, которые вы хотите, но Я не могу точно сказать по вашему вопросу ... например, если chunk[5] равно 65, когда вы напечатаете его как cout << chunk[5];, вы получите букву 'A'.

Однако вы можете спросить, как распечатать фактическое число 65, и в этом случае вы хотите сделать cout << int(chunk[5]);. Приведение к int заставит его печатать как целочисленное значение, а не как символ. Если вы уточните свой вопрос, я или кто-то еще можем вам помочь.

Answer 7

Это то, что вы пытаетесь достичь:

char* p = (char*)malloc(10 * sizeof(char));
char* p1 = p;
memcpy(p,"abcdefghij", 10);

for(int i = 0; i < 10; ++i)
{
    char c = *p1;
    cout<<c<<" ";
    ++p1;
}
cout<<"\n";
free(p);

Answer 8

char* ptr = pAddressOfMemoryToRead;

while(ptr < pAddressOfMemoryToRead + blockLength)
{
     char tmp = *ptr;
     // temp now has the char from this spot in memory
     ptr++;
}

Answer 9

Как то так?

char *buffer = (char*)malloc(42);
// ... put something into the buffer ...
printf("%c\n", buffer[0]);

Но, так как вы используете C ++, мне интересно, почему вы беспокоитесь о malloc и подобных ...