How to demonstrate memory error using arrays in C++

Question

I'm trying to think of a method demonstrating a kind of memory error using Arrays and C++, that is hard to detect. The purpose is to motivate the usage of STL vector<> in combination with iterators.

Edit: The accepted answer is the answer i used to explain the advantages / disadvantages. I also used: this

Answer 1

Improperly pairing new/delete and new[]/delete[].

For example, using:

int *array = new int[5];
delete array;

instead of:

int *array = new int[5];
delete [] array;

And while the c++ standard doesn't allow for it, some compilers support stack allocating an array:

int stack_allocated_buffer[size_at_runtime];

This could be the unintended side effect of scoping rules (e.g constant shadowed by a member variable)... and it works until someone passes 'size_at_runtime' too large and blows out the stack. Then lame errors ensue.

Answer 2

A memory leak? IMO, vector in combination with iterators doesn't particularly protect you from errors, such as going out of bounds or generally using an invalidated iterator (unless you have VC++ with iterator debugging); rather it is convenient because it implements a dynamically resizable array for you and takes care of memory management (NB! helps make your code more exception-safe).

void foo(const char* zzz)
{
    int* arr = new int[size];
    std::string s = zzz;
    //...
    delete[] arr;
}

Above can leak if an exception occurs (e.g when creating the string). Not with a vector.

Vector also makes it easier to reason about code because of its value semantics.

int* arr = new int[size];
int* second_ref = arr;
//...
delete [] arr; 
arr = 0; //play it safe :)

//...
second_ref[x] = y;
//...
delete [] second_ref;

But perhaps a vector doesn't automatically satisfy 100% of dynamic array use cases. (For example, there's also boost::shared_array and the to-be std::unique_ptr<T[]>)

Answer 3

Why don't you motivate it based on the algorithms that the STL provides?

Answer 4

One obvious:

for (i = 0; i < NUMBER_OF_ELEMENTS; ++i)
    destination_array[i] = whatever(i);

versus

for (i = 0; i < NUMBER_OF_ELEMENTS; ++i)
    destination_vector.push_back(whatever(i));

pointing out that you know the second works, but whether the first works depends on how destination_array was defined.

Answer 5

I think the utility of std::vector really shows when you need dynamic arrays.

Make one example using std::vector. Then one example using an array to realloc. I think it speaks for itself.

Answer 6

void Fn()
{
    int *p = new int[256];
    if ( p != NULL )
    {
        if ( !InitIntArray( p, 256 ) )
        {
              // Log error
              return;
        }
        delete[] p;
    }
}

You wouldn't BELIEVE how often I see that. A classic example of where any form of RAII is useful ...

Answer 7

I would think the basic simplicity of using vectors instead of dynamic arrays is already convincing.

1. You don't have to remember to delete your memory...which is not so simple since attempts to delete it might be bypassed by exceptions and whatnot.
2. If you want to do dynamic arrays yourself, the safest way to do it in C++ is to wrap them in a class and use RAII. But vectors do that for you. That's kind of the point, actually.
3. Resizing is done for you.
4. If you need to support arbitrary types, you don't have to do any extra work.
5. A lot of algorithms are provided which are designed to handle containers, both included and by other users.
6. You can still use functions that need arrays by passing the vector's underlying array if necessary; The memory is guaranteed to be contiguous by the standard, except with vector<bool> (google says as of 2003, see 23.2.4./1 of the spec).
7. Using an array yourself is probably bad practice in general, since you will be re-inventing the wheel...and your implementation will almost definitely be much worse than the existing one...and harder for other people to use, since they know about vector but not your weird thing.

With a dynamic array, you need to keep track of the size yourself, grow it when you want to insert new elements, delete it when it is no longer needed...this is extra work. Oh, and a warning: vector<bool> is a dirty rotten hack and a classic example of premature optimization.

Answer 8

In raw array, operator[] (if I may call so) is susceptible to index-out-of-bound problem. With vector it is not (There is at least a run time exception).

Sorry, I did not read the question carefully enough. index-out-of-bound is a problem, but not a memory error.