Segmentation fault caused by memcpy despite counting every bit - c++

Question

I am trying to copy data from an array of characters into a member of my class using memcpy. I set a breakpoint in the debugger write before memcpy. I checked all of the variables that I will be using and the i calculated how much space is left in the destination and it looks like it should work.
#include <iostream>
#include <cstdlib>
#include <cstring>
class bigNum
{
unsigned int dataLength;
unsigned long long int *data;
public:
bigNum(){
//long long int is 8 bytes so (2 * 1024)long long int = 16 KiB
// if that's not enough, we can always add more later
dataLength = 2048;
data = new unsigned long long [dataLength];
};
virtual ~bigNum(){delete[] data;};
//bigNum& operator=(const bigNum& other);
bigNum& set(char chars[], unsigned int charsLength) {
//calculate where we will start writing the data
void *writeStart = (void*)(
(unsigned long long)data + dataLength*64 - charsLength*8
);
//DEBUG -- set a couple of the array elements to watch in debugger
data[2047] = data[2046] = ~((unsigned long long)0);
//zero out the space before writeStart
std::memset(data, 0, dataLength*8 - charsLength);
//write the data starting at writeStart
std::memcpy(writeStart, chars, charsLength);
return *this;
}
};
using namespace std;
int main()
{
bigNum myNum;
char chars[9] = {'a'};
myNum.set(chars, 9);
system("PAUSE");
return 0;
}

Answer 1

The bug is in this statement here:
void *writeStart = (void*)(
(unsigned long long)data + dataLength*64 - charsLength*8
);
That is, it appears you're trying to get the right write location in bits, when you should be doing this in bytes.
When you have statements like dataLength*64 and charsLength*8, you're multiplying by their sizes in bits, when what you're dealing with - pointers - refers to bytes.
But still, it seems you're playing loose with integer sizes. Don't do that! It means your code will break on other machine architectures. Instead of assuming that unsigned long long is 64 bits, find out exactly how many bytes they are using sizeof(unsigned long long), or if you want a fixed width integer, use the corresponding type like uint64_t.
Then again, with C++, you should stick to standard containers like std::vector.