Help with implementing a function to change size of dynamic array

Question

I'm trying to write a function that will change the size of a dynamic array to a new size. In my header file, I have:

Image **images; //pointer to a dynamic array of image pointers
int maximum; //size

I want to do this by allocating a new array and copying the values over without changing their indices. If there are non-null pointers outside the range newmax, then we cant do this. So heres what I have:

There are no compilation or runtime errors. However, I find that the new array isnt getting sized right. When I run the following test case:

I should get an index out of bounds error, but instead the system lets it slide. Can anyone see the mistake? I've looked for hours but cant find anything.

you can use std::vector<Image*> instead of Image** and save some time — Andriy Tylychko
– Andriy Tylychko, Commented Feb 13, 2011 at 22:49
What Andy T said, times 100 :) Once you're familiar with vector, you'll never have to worry about this again! — j_random_hacker
– j_random_hacker, Commented Feb 13, 2011 at 22:51
Why would you expect an out of bounds error? Are you throwing one from addpicture() — Benjamin Lindley
– Benjamin Lindley, Commented Feb 13, 2011 at 23:01
@iRobot: To clarify, C++ does not do bounds checking on arrays. — Benjamin Lindley
– Benjamin Lindley, Commented Feb 13, 2011 at 23:09

Keith · Accepted Answer · 2011-02-13 23:09:17Z

1

  images=newArray;
  for (int i =0;i<newmax;i++)
        *images[i]=*newArray[i];

This is odd. images and newArray are now the same, hence no need to copy the contents of newArray back to itself. So remove this loop? Also, need to add:

 maximum = newmax;

If the '1' is the index, this should cause

 firstScene->addpicture("red10.bmp", 1, 13, 72);

to give an out of bounds error, whereas at the moment it might seg fault?

answered Feb 13, 2011 at 23:09

Keith

6,84422 silver badges24 bronze badges

Sign up to request clarification or add additional context in comments.

5 Comments

iRobot Over a year ago

Wow thats it! I needed maximum=newmax. I completely overlooked that part. Question: does images=newArray just assign the memory address of newArray to images? Doesnt newArray go out of scope as soon as the function call is over?

Keith Over a year ago

newArray is a pointer to an array. Yes the assignment just copies the pointer. So yes, the original pointer it goes out of scope, but the array it points to is on the heap and remains there. images then continues to point to that array.

iRobot Over a year ago

So the pointer of newArray goes out of scope, but since we copied it over to images, its still alive?

Keith Over a year ago

PS. Nothing wrong with learning how to implement your own dynamic array. Standard library containers are fantastic and should be the default for production code, but if you never try to implement your own, you'll not got the most out of them.

Keith Over a year ago

'still alive' in C++ really means that you can still navigate to it. There is no garbage collection etc what would clean it up anyway.

Fred Nurk · Accepted Answer · 2011-02-13 23:31:31Z

You should extract this functionality to a separate class and have a data member in Scene of that type:

struct ImagePtrVector {
  typedef Image *value_type;
  typedef int size_type;

  ImagePtrVector() : _begin (), _end (), _end_alloc () {}
  ~ImagePtrVector() {
    for (value_type x = _begin; x != _end; ++x) {
      delete *x;
    }        
    delete[] _begin;
  }

  // Either define these two yourself or mark private:
  ImagePtrVector(ImagePtrVector const &x);
  ImagePtrVector& operator=(ImagePtrVector const &x);

  value_type& operator[](size_type index) {
    assert(0 <= index);  // Or other checking as you like.
    assert(index < size());
    return _begin[index];
  }
  value_type const& operator[](size_type index) const {
    assert(0 <= index);  // Or other checking as you like.
    assert(index < size());
    return _begin[index];
  }

  size_type size() const { return _end - _begin; }
  size_type capacity() const { return _end_alloc - _begin; }

  void reserve(size_type capacity) {
    if (this->capacity() < capacity) {
      value_type *new_begin = new value_type[capacity];
      // Exception-safe only because I know the below won't throw.

      std::copy(_begin, _end, new_begin);
      _end_alloc = new_begin + capacity;
      _end = new_begin + this->size();
      delete[] _begin;
      _begin = new_begin;
    }
  }

  void resize(size_type size) {
    reserve(size);
    for (size_type diff = size - this->size(); diff > 0; --diff) {
      *_end++ = new Image();
    }
  }

  // Add push_back, begin/end, etc. to taste.

private:
  value_type *_begin, *_end, *_end_alloc;
};

The differences from std::vector and boost::ptr_vector are not coincidence, and you should evaluate whether you really need to write a special container or can reuse an existing generic container.

Collectives™ on Stack Overflow

Help with implementing a function to change size of dynamic array

2 Answers 2

5 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

5 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related