Copying char**** as contiguous data to a char* variable - c++

Question

How can I copy everything from char**** first to a contiguous variable: char* second without using nested loops?
For example, I could use nested for loops that would look like this:
for (size_t a=0; a < sizeof(***first); a++) {
for (size_t b=0; b < sizeof(**first); b++) {
//etc
}
}
I just want to know if this is possible.

Answer 1

You seem to have a serious misconception about what sizeof does.
sizeof(x) returns the size in bytes of object x. When dealing with pointers sizeof(*x) is not going to be in general the same as the number of elements that x is pointing to.
Note also that, in the cases you are using, sizeof(x) is a value decided at compile time and sizeof(*x) doesn't even look at what x is pointing to (only looks to what is the type of the object x is pointing to: for example with int *x = NULL; the expression sizeof(*x) is the same as sizeof(int)).
Moreover you need to understand the difference between a multi-dimensional array of ints:
int x[10][10];
and a pointer to a pointer to an int:
int **y;
Even if the two can be dereferenced using the same syntax
x[1][2] = 42;
y[1][2] = 42;
the meaning is completely different. More specifically for example y[0] and y[1] may be pointing to (the first elements of) arrays of different sizes, they may be NULL or the may point to single integers (y[0] and y[1] could even be pointing to the same object).
There is no way to copy a pointer-pointer data structure into a multidimensional array without loops because the two are in general objects with a completely different kind of shape.

Answer 2

IFF you know the individual sizes of the multidimensional arrays, you can flatten the array in a single loop. It should be noted though that you might not actually see a performance increase of flattening an array in 1 loop over having some nested loops; it can depend on your compiler optimizations (like vectorization) and platform/architecture, as well, if you have to determine the size of each nested array you'll incur a performance hit there on top of the large loop. YMMV, so it's best to do some small scale benchmarks to verify it achieves the result and performance you're wanting.
The following is some example code on how to flatten an array; note that I'm using a std::string type in this example just so you can run the code and print to a file/stdout to see that the array has indeed been flattened.
#include <iostream>
#include <string>
#include <sstream>
void flatten(std::string**** first, int len_a, int len_b, int len_c, int len_d, std::string* second)
{
int i, a, b, c, d;
int max_len = len_a * len_b * len_c * len_d;
a = b = c = d = -1;
for (i = 0; i < max_len; ++i) {
d = (i % len_d);
// if all lengths were equal, you could further optimize this loop
if (d == 0) {
++c;
if ((c % len_c) == 0) {
c = 0;
++b;
if ((b % len_b) == 0) {
b = 0;
++a;
}
}
}
second[i] = first[a][b][c][d];
}
}
int main()
{
const int len_a = 11;
const int len_b = 22;
const int len_c = 33;
const int len_d = 44;
const int max_len = len_a * len_b * len_c * len_d;
// create the arrays
std::string**** first = new std::string***[len_a];
std::string* second = new std::string[max_len];
for (int i1 = 0; i1 < len_a; ++i1) {
first[i1] = new std::string**[len_b];
for (int i2 = 0; i2 < len_b; ++i2) {
first[i1][i2] = new std::string*[len_c];
for (int i3 = 0; i3 < len_c; ++i3) {
first[i1][i2][i3] = new std::string[len_d];
for (int i4 = 0; i4 < len_d; ++i4) {
std::stringstream ss;
ss <<"["<<i1<<"]["<<i2<<"]["<<i3<<"]["<<i4<<"]";
first[i1][i2][i3][i4] = ss.str(); // or what have you
}
}
}
}
// flatten the multidimensional array 'first' into the array 'second'
flatten(first, len_a, len_b, len_c, len_d, second);
// print it
for (int i1 = 0; i1 < max_len; ++i1) {
std::cout<<"second["<<i1<<"] = "<<second[i1]<<std::endl;
}
// clean up
delete[] second;
for (int i1 = 0; i1 < len_a; ++i1) {
for (int i2 = 0; i2 < len_b; ++i2) {
for (int i3 = 0; i3 < len_c; ++i3) {
delete[] first[i1][i2][i3];
}
delete[] first[i1][i2];
}
delete[] first[i1];
}
delete[] first;
return 0;
}
Again, this is obviously not a safe/clean/efficient method of doing what you're looking for, but I'm merely trying to demonstrate that you can achieve it and I'll leave further efficiencies/implementation details to you.
I hope that can help.