C / C++ / MFC

ForNow wrote:

C++

s = new char[63];
::memcpy(s, t, 62);
k = s + 62;
::memcpy(k, &thenullptr, 1);    <------- call which causes read exception or overwrite

s = new char[63] {0};
::memcpy(s, t, 62);

s = new char[63];
s[62] = '\0';
::memcpy(s, t, 62);

char* t = new char[70];

// do stuff with t

delete[] t;

#include <iostream>
#include <cstddef>
using namespace std;

// in [INPUT]  - the binary array we wish to represent with an hex string
// size_in [INPUT] - the size (bytes) of the binary array
// out [OUTPUT] - the buffer receiving the hexadecimal representation of the binary data
// out_size [INPUT] - the size of the buffer. It should be at least (size_in*2+1) in order ot represent all the input data
size_t to_hex( unsigned char in[], size_t size_in, char out[], size_t size_out)
{
  size_t n;
  for (n=0; (n < size_in) && (n < (size_out-1)b/2); ++n)
  {
    unsigned char nibble;
    nibble = (in[n] >> 4); // the MSB nibble
    out[2*n] = nibble < 10 ? nibble + '0' : nibble - 10 + 'A';
    nibble = (in[n] & 15); // the LSB nibble
    out[2*n+1] = nibble < 10 ? nibble + '0' : nibble - 10 + 'A';
  }

  if ( 2*n < size_out)
    out[2*n] = '\0';

  return n;
}

// a little test
int main()
{
  unsigned char small[] = { 0x25, 0x37, 0x48, 0x42, 0x42 };

  char buffer[41];

  size_t size = to_hex( small, sizeof(small), buffer, sizeof(buffer));
  cout << "converted bytes " << size << ", hex string " << buffer << "\n";


  unsigned char large[256];
  for (size_t n=0; n<256; ++n)
  {
    large[n] = n;
  }

  size = to_hex( large, sizeof(large), buffer, sizeof(buffer));
  cout << "converted bytes " << size << ", hex string " << buffer << "\n";
}

std::string(const char *, size_t count)

unsigned char datum[6]{ 'A', 'B', 'C', 'D', 'E', 'F' };  // a non-nul terminated sequence of bytes
std::string str(reinterpret_cast<const char *>(datum), 4); // assuming we just want the first 4 bytes from datum

returnsource->stmt = convertToString(sourcerecordpointer->statementnumber, 4);

ForNow wrote:

I have a number of hex data I am trying to get to printable data I mean ascii
I read them as a byte[] array where byte is typedef for usigned char
I just got this idea it might be easier to manipulate it as string i mean like std::string

ForNow wrote:

After I finish inserting the bytes do I have to add a null 0x00 to complete the string or string will do that automatically ?

#include <iostream>
using namespace std;

typedef unsigned char BYTE;

struct source
{
  string stmt;
  string loc;
  string addr1;
  string addr2;
};


// converts character array
// to string and returns it
string convertToString(unsigned char* a, int size)
{
    int i;
    string s = "";
    for (i = 0; i < size; i++) {
        s += a[i];
    }
    return s;
}


int main()
{

  BYTE statementnumber[4];

  source * returnsource = new source;

  returnsource->stmt = convertToString(statementnumber, 4);

  delete returnsource;
}