Copying a CByteArray into an array of Bytes causes an access violation

Question

While investigating a dump, I'm dealing with an access violation, caused by this piece of source code:

CByteArray baInput;
... // baInput gets filled in with 9804 entries
BYTE* result;
result = new BYTE[baInput.GetSize()]; // baInput.GetSize() gives 9804, as expected.
memcpy (result, &baInput, baInput.GetSize()); // access violation

In order to understand what's going on, I've added sizeof(result) in the watch-window, which yields 8 (while I expected 9804), but I'm not sure if this is the right thing to do here.

I'd like to be really sure that the reservation of memory for the result variable has been performed successfully. How can I do that?

Does anybody have an idea what might be going wrong here?
Thanks in advance

Oh, I forgot: I'm working on a Windows environment, most probably Windows-10.
The programming environment is based on Windows kits, version 8.1.
CByteArray is MFC code.

I don't know if this is relevant, but the CByteArray contains quite some backslash characters.

`sizeof(result)` is a size of pointer to the array (`BYTE*`), not the whole array. — Piotr Siupa, Jun 05 '18 at 11:59
`&baInput` is a pointer to the `CByteArray` ***object***, not the "array" is contains or wraps. — Some programmer dude, Jun 05 '18 at 11:59
What library are you using? Neither `CByteArray` nor `BYTE` is a part of C++ standard. — Piotr Siupa, Jun 05 '18 at 12:00
@NO_NAME: I've added explanation about the mentioned type definitions. — Dominique, Jun 05 '18 at 12:04
I'm can't verify it rn but replacing `&baInput` with `baInput.GetData()` should work. Generally, never treat object as simple types. Always use proper functions on them. — Piotr Siupa, Jun 05 '18 at 12:09

score 3 · Accepted Answer · answered Jun 05 '18 at 14:27

Unlike other MFC classes, CByteArray does not come with a static buffer in front of all other class members, nor a dereferencing operator. Thus the wrapped byte array can't be accessed by dereferencing the CByteArray variable. (Doing that will give you a pointer to the memory location of the wrapper class, as others mentioned)

It does however inherit and override GetData() from CObArray which grants readonly access to the wrapped array. With this you can adjust your code to the following:

CByteArray baInput;
...
BYTE* copy = new BYTE[baInput.GetSize()];
memcpy(copy, baInput.GetData(), baInput.GetSize());

Using C++ however, the better approach would be using a vector for the data:

CByteArray baInput;
...
std::vector<BYTE> copy(baInput.GetData(), baInput.GetData() + baInput.GetSize());

Note that there are several ways to assign the data to the vector. This one treats the source pointers as iterators and is one of the quickest. You can also access the vector's data using std::vector::data() later on again.

Your first proposal, using `baInput.GetData()` instead of `&baInput`, has solved my problem. The second proposal might cause more modifications to be done, so I just went for the first one. — Dominique, Jun 06 '18 at 11:16
The second approach doesn't cause any modifications to be done to the array data *unless* you perform modifying operations on the vector such as `push_back()` or `erase()`. It will wrap the data just nicely, enables it to modern C++ standard functionality and allows for way less room for error. If you're worried about performance, it's nearly as fast as approach #1 as vector implementation is very well optimized by modern day compilers. See: [vector assignment vs std::copy](https://stackoverflow.com/questions/14977632/copying-stdvector-prefer-assignment-or-stdcopy) — Vinz, Jun 06 '18 at 19:26

Copying a CByteArray into an array of Bytes causes an access violation

1 Answers1