Effective array chunking in C++(Intro to pointers)

Nick Alvarez — Fri, 10 Aug 2018 23:31:20 +0000

Array chunking is a very common problem in programming but in most cases you will only need one large array after chunking and can discard any subarrays used to create it. This page is going to address the more rare case of when you will need to create a large array from several smaller arrays, apply changes to that large array, and distribute any changes made to it to each subarray efficiently. Instead of indexing through the larger array twice (once to set the values then once to distribute the values into each subarray) we will build a function that allows any changes made to the large array to also be made to the corresponding subarrays, allowing us to skip indexing through the large array a second time.

Visualizing the problem

Using multiple arrays

int array0[3] = {0,1,2};
int array1[3] = {3,4,5};
int array2[3] = {6,7,8};

We want to pass the above arrays into some function that will combine them into one large array

int largeArray[9] = {0,1,2,3,4,5,6,7,8};

This function should also make it possible for each subarray to keep the changes applied to the large array. After executing these lines:

for(int i = 0; i<9; i++)
{
    largeArray[i] += 1;
}

Printing each array should give these outputs:

Large array: 1,2,3,4,5,6,7,8,9
array0: 1,2,3
array1: 4,5,6
array2: 7,8,9

This is an interesting problem if you haven't delt with it before and I'd encourage you to brain storm to try to come up with the answer before reading on. So without further ado, creating the function.

Creating the function

It is easy to see our regular approach of indexing through the larger array and setting each index to the corresponding integer of the subarrays won't work since changes made to the larger array won't be made to the subarrays after being set. It may already be obvious what needs to be done and if it is you're one smart cookie. Our large array will not be the same type as our subarrays, at least not really. Instead of using integer subarrays to construct a larger array of integers, we will use integer subarrays to construct a larger array of integer pointers. And instead of setting each index of the larger array to the integers of the subarray, we will set each pointer of the larger array to the memory addresses of the integers in each subarray. Cool right! But now how to code this.

How to code this

One of my all time favorite pages to help better understand how to manipulate pointers that I wish I could take credit for is here. But without further ado. Here's the code.

void Executive::Combine(int size, int * Holder[], int input0[], int input1[], int input2[])
{
        for(int i = 0; i<size; i++)
        {
                Holder[i] = &input0[i];
                Holder[i+size] = &input1[i];
                Holder[i+size*2] = &input2[i];
        }
}

A simple function to understand once you know what the ampersand is used for. The ampersand is used to set the memory address rather than the value of the memory address the pointer is pointing to. So in this case we are first setting the pointer of 'Holder' at index 'i' to the memory address of our 'input0' at index 'i'. As 'i' increases we will fill the Holder array with the proper memory addresses of the subarrays allowing any changes made to the larger area to be carried to each subarray.

Testing

Here lets build some code to test out our function.

int array0[3] = {0,1,2};
int array1[3] = {3,4,5};
int array2[3] = {6,7,8};
int * largeArray[9];

Combine(3,largeArray,array0,array1,array2);

cout<<"After combining:"<<endl;
for(int i=0; i<9; i++){
        cout<<*largeArray[i];
}
for(int i=0; i<9; i++){
        *largeArray[i]+=1;
}
cout<<endl<<"After addition:"<<endl;
for(int i=0; i<9; i++){
        cout<<*largeArray[i];
}
cout<<endl<<"array0:"<<endl;
for(int i=0; i<3; i++){
        cout<<array0[i];
}
cout<<endl<<"array1:"<<endl;
for(int i=0; i<3; i++){
        cout<<array1[i];
}
cout<<endl<<"array2:"<<endl;
for(int i=0; i<3; i++){
        cout<<array2[i];
}

You may have noticed that a few stars * are slipped into the code. That's because this symbol is used to accessing a pointers value. All the other arrays used are just integer arrays so there's no need to use them there. Without using stars on a pointer you'll be printing the actual memory addresses of the pointers and you may end up printing something like this.

After addition:
0xffffcb8c0xffffcb900xffffcb940xffffcb800xffffcb840xffffcb880xffffcb740xffffcb780xffffcb7c

Desired outputs

After combining:
012345678
After addition:
123456789
array0:
123
array1:
456
array2:
789