--- title: Effective array chunking in C++(Intro to pointers) published: true description: How to combine multiple subarrays into a larger area that tracks and distributes changes into the subarrays used to create it. tags: #cplusplus #programming #beginners --- Array chunking is a very common problem in programming but in most cases you will only need one large array after chunking and can disgard any subarrays used to create it. This page is going to address the more rare case of when chunking into a large array will provide efficiency but we still need the changes made to the larger array to be kept in each subarray. 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, allowing us to skip indexing through the large array a second time. ####Visualizing the probem Using multiple arrays ```c++ int array0[3] = {0,1,2}; int array1[3] = {3,4,5}; int array2[3] = {6,7,8}; ``` We want to pass these arrays into some function that will combine these into one large array ```c++ 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: ```c++ for(int i = 0; i<9; i++) { largeArray[i] += 1; } ``` Printing each array should give these outputs: ```c++ 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](https://gist.github.com/ericandrewlewis/720c374c29bbafadedc9). But without further ado. Here's the code. ```c++ void Executive::Combine(int size, int * Holder[], int input0[], int input1[], int input2[]) { for(int i = 0; i

bcverdict

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

Join Our Newsletter. No Spam, Only the good stuff.