Merge sort (sorted arrays)

I have some already sorted arrays of the same type and I want to sort them efficiently into one array. I guess the best method is the merge sort. Each element of these arrays is an object user-defined and has a size of about 8 integers. My question is if it is worthy to create an array of pointers to the elements of these arrays, which pointers will be ordered according to the value of the objects instead of a new array with a copy of the objects.
For example, given the arrays Objects a[], b[], c[], d[] I create the array Objects *sorted[].

sorted[0] = &b[0];
sorted[1] = &d[0];
sorted[2] = &a[0];
sorted[3] = &a[1]'
sorted[4] = &c[0];
...

Note: I don't want to loose the initial arrays from the memory.

I understand you don't want to modify either of the original arrays? But you do expect them to hang around long enough for you use a sorted array of pointers to their items?

Just create a large array of pointers. You don't even need merge sort. It is simpler than that; all you need to do is perform one merge phase. That should go really fast!

Memory usage: Creating an array of pointers and sorting based on that uses less memory.
Speed: 32 bytes isn't too big for an item, and as long as the copy-constructor is trivial it should copy pretty fast, but not as fast as a just writing a pointer.

Indeed. I don't want to modify the original array because I have use of them as they are.
The point that I have 5 arrays. If I construct the big sorted array using pointers, I need 4 times to do merge. Is it more efficient to use the implementation of the arrays of pointer 4 times or is it better to copy the values each time into one array with the sum of the sizes of the two initial arrays?

You simply want a k-way merge. Here is some sample code for how to implement that (untested):

Code:

---

//Inputs a .. e
const object a[42]; // can be any length
//...
const object e[1337]; // can be any length

//Output
object *out[42+...+1337];

struct Inputs {
    object *ptr;
    int count;
    bool operator < (const Inputs & b) { return *ptr < *(b.ptr); }
};

//Setup
Inputs in[5];
int alive = 5, idx = 0;
in[0].ptr = a; in[0].count = 42;
//...
in[4].ptr = e; in[4].count = 1337;

while (alive > 0)
{
    //TODO: Insert basic algorithm here, to sort 'alive' items in array 'in'
    //by what their 'ptr' points to e.g. std::sort(in[0], in[5]);

    out[idx++] = in[0].ptr++;
    if (--in[0].count == 0)
        in[0] = in[--alive];
}
//Done: output is in the 'out' array.

---