如何在c ++中将内存块读取为char

Question

您好，我有一块包含位（位字面量）的内存（使用 malloc() 分配），我想将其读取为 char 数组，或者，更好的是，我想打印出 ASCII内存中连续 8 位的值。

我已将他的内存分配为 char *，但我无法以比评估每个位更好的方式取出字符，将值添加到 char 并在循环中左移 char 的值，但我一直在寻找更快的解决方案。 谢谢

我现在写的是这样的：

分配：

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

写给内存：

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”写入内存 （AAAB 的 ASCII 值是 65656566 位）

那我希望它有把内存内容改写成文件的功能。

因此，如果内存再次包含“01000001010000010100000101000010”，它将写入输出文件“AAAB”。

Answer 1

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 2

如果你想访问内存块中的每一个bit，看起来你需要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 3

我想打印出内存中连续 8 位的 ASCII 值。

任何位的可能值是 0 或 1。您可能至少需要一个字节。

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

在堆上分配 1 个字节。一个更高效、更轻松的事情是在堆栈上创建一个对象，即：

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

ifstream 明文；

cleartext.open(sometext);

上面没有写任何东西给内存。它尝试以输入模式打开文件。

它有ascii字符和常见的eof或\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 4

这样的？

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

但是，既然您使用的是 C++，我想知道您为什么要打扰 malloc 之类的...

Answer 5

char* ptr = pAddressOfMemoryToRead;

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

Answer 6

这是你想要达到的目标吗：

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 7

您能否更详细地解释一下，也许包括代码？除非我完全误读了您的问题，否则您所说的毫无意义。你在做这样的事情吗？

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

如果是这样，您可以通过将chunk 视为数组来访问任何字符的数据：chunk[5] 为您提供第 5 个元素等。当然，这些将是字符，这可能是您想要的，但是我不能从你的问题中完全看出...例如，如果chunk[5] 是 65，当你像cout << chunk[5]; 一样打印它时，你会得到一个字母'A'。

但是，您可能会问如何打印出实际的数字 65，在这种情况下您想要执行cout << int(chunk[5]);。转换为 int 将使其打印为整数值而不是字符。如果您澄清您的问题，我或其他人可以进一步帮助您。

Answer 8

您是在问如何将任意结构的内存字节复制到 char* 数组中？如果是这样，这应该可以解决问题

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

Answer 9

我不确定我是否完全理解您想要做的事情，但有几点建议：

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 输入传递给它，您将得到一个可打印的位串。体面的编译器会为此生成良好的输出代码...您需要多高的速度？