1

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

我已将他的内存分配为 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”。

4

9 回答 9

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';
}
于 2009-03-17T18:12:39.783 回答
1

如果你想访问内存块中的每一位，看起来你需要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];
    }
}
于 2009-03-17T18:21:53.193 回答
1

我想打印出内存连续 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());
于 2009-03-17T18:33:27.983 回答
0

像这样的东西？

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

但是，既然你使用的是 C++，我想知道你为什么要这么麻烦malloc……

于 2009-03-17T18:03:33.843 回答
0 
char* ptr = pAddressOfMemoryToRead;

while(ptr < pAddressOfMemoryToRead + blockLength)
{
     char tmp = *ptr;
     // temp now has the char from this spot in memory
     ptr++;
}
于 2009-03-17T18:06:42.200 回答
0

这是你想要实现的目标：

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);
于 2009-03-17T18:06:56.613 回答
0

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

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

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

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

于 2009-03-17T18:08:49.760 回答
0

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

SomeType t = GetSomeType();
char* ptr = malloc(sizeof(SomeType));
if ( !ptr ) {
  // Handle no memory.  Probably should just crash
}
memcpy(ptr,&t,sizeof(SomeType));
于 2009-03-17T18:11:59.127 回答
0

我不确定我是否完全理解您正在尝试做的事情，但有一些建议：

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

于 2009-03-17T18:55:31.380 回答