title: Removing elements from dynamic arrays
body: <p>So, I have this:</p>
  
  <pre><code>#include &lt;stdio.h&gt;
  #include &lt;stdlib.h&gt;
  #include &lt;string.h&gt;
  
  void remove_element(int* array, int sizeOfArray, int indexToRemove)
  {
      int* temp = malloc((sizeOfArray - 1) * sizeof(int*)); // allocate an array with a size 1 less than the current one
      memcpy(temp, array, indexToRemove - 1); // copy everything BEFORE the index
      memcpy(temp+(indexToRemove * sizeof(int*)), temp+((indexToRemove+1) * sizeof(int*)), sizeOfArray - indexToRemove); // copy everything AFTER the index
      free (array);
      array = temp;
  }
  
  int main()
  {
      int howMany = 20;
      int* test = malloc(howMany * sizeof(int*));
  
  
      for (int i = 0; i &lt; howMany; ++i)
          (test[i]) = i;
  
  
  
      printf("%d\n", test[16]);
      remove_element(test, howMany, 16);
      --howMany;
      printf("%d\n", test[16]);
      return 0;
  }
  </code></pre>
  
  <p>It's reasonably self-explanatory, remove_element removes a given element of a dynamic array.</p>
  
  <p>As you can see, each element of test is initialised to an incrementing integer (that is, test[n] == n). However, the program outputs</p>
  
  <pre><code>16
  16
  </code></pre>
  
  <p>.
  Having removed an element of test, one would expect a call to to test[n] where n >= the removed element would result in what test[n+1] would have been before the removal. So I would expect the output</p>
  
  <pre><code>16
  17
  </code></pre>
  
  <p>. What's going wrong?</p>
  
  <p>EDIT: The problem has now been solved. Here's the fixed code (with crude debug printfs), should anyone else find it useful:</p>
  
  <pre><code>#include &lt;stdio.h&gt;
  #include &lt;stdlib.h&gt;
  #include &lt;string.h&gt;
  
  int remove_element(int** array, int sizeOfArray, int indexToRemove)
  {
      printf("Beginning processing. Array is currently: ");
      for (int i = 0; i &lt; sizeOfArray; ++i)
          printf("%d ", (*array)[i]);
      printf("\n");
  
      int* temp = malloc((sizeOfArray - 1) * sizeof(int)); // allocate an array with a size 1 less than the current one
  
      memmove(
              temp,
              *array,
              (indexToRemove+1)*sizeof(int)); // copy everything BEFORE the index
  
      memmove(
              temp+indexToRemove,
              (*array)+(indexToRemove+1),
              (sizeOfArray - indexToRemove)*sizeof(int)); // copy everything AFTER the index
  
  
      printf("Processing done. Array is currently: ");
      for (int i = 0; i &lt; sizeOfArray - 1; ++i)
          printf("%d ", (temp)[i]);
      printf("\n");
  
      free (*array);
      *array = temp;
      return 0;
  
  }
  
  int main()
  {
      int howMany = 20;
      int* test = malloc(howMany * sizeof(int*));
  
  
      for (int i = 0; i &lt; howMany; ++i)
          (test[i]) = i;
  
  
  
      printf("%d\n", test[16]);
      remove_element(&amp;test, howMany, 14);
      --howMany;
      printf("%d\n", test[16]);
      return 0;
  }
  </code></pre>