New and arrays size

Question

I have a dynamically created array of integers. Now I have to remove all elements which have index %3 == 0. (for example, 3, 6, 9, ...). So, what is the best way to decrease array size? With malloc I can use realloc for the same part of memory, but what about new operator? What to do this way. Just slide all elements left, make zero to all another elements?

Answer 1

#include <algorithm>
#include <iostream>
#include <vector>

bool IsDividedByThree (int i) { return ((i%3)==0); }

int RandomNumber () { return (rand()%100); }

int main()
{
    std::vector<int> myInts(50);

    std::generate(myInts.begin(), myInts.end(), RandomNumber);

    std::copy(myInts.begin(), myInts.end(), std::ostream_iterator<int>(std::cout, " "));

    myInts.erase(std::remove_if(myInts.begin(), myInts.end(), IsDividedByThree), myInts.end());

    std::copy(myInts.begin(), myInts.end(), std::ostream_iterator<int>(std::cout, " "));

}

Isn't so nice that STL takes care everything for you?

Hm didn't see comment, in which one is forced not to use STL.

The C version:

    int *temp = new int[NEW_SIZE];
    memcpy( temp , old_array, size_of_old_array * sizeof(int) );
    delete[] old_array;
    old_array = temp;

1. create the array dynamically
2. create a new array with the new size
3. copy the elements from the first to the second array
4. delete the first array
5. redirect the pointer to the first array to the second

All these answer So, what is the best way to decrease array size? - I assumed you already knew how to solve the rest of your problem.

Answer 2

I'd simply allocate a new smaller array and then copy elements to it. Something like this (this includes the element at 0 index):

int* array = new int [original_size];

// fill array

size_t new_size = original_size - original_size / 3 - 1; // i think i got this right, untested
int* new_array = new int [new_size];

for (int i = 0, int j = 0; i < original_size; i++)
{
    if (i % 3 == 0)
    {
        new_array[j] = array[i];
        j++
    }
}

delete [] array;
array = new_array;
new_array = nullptr;

You can of course work in place and shift elements to the left. But you can't delete a part of array that was allocated via new[].

Since this is an exercise, and you can't use STL, why don't you try to implement a simple vector class yourself?

Answer 3

Simply setting data elements to 0 wont free them. And when you allocate new memory for the resized array, you need to copy all of the elements from previous memory.

I would suggest you to implement it as a linked list.

Answer 4

You can use placement new operator in C++. (#include <new> is required). For example

#include <new>

int main(int argc, char **argv) {
    double *b = new double[10];
    new(b) double[8];

    delete [] b;
}