Catching vector index out of bounds

[Biff]

Is there a common way to check for vector indexes being in bounds? My
version of the STL has no such check, even in debug builds. I was
considering deriving a class from Vector with its own operator[], and using
that in my code instead of std::vector. Then I'd use an #ifdef _DEBUG
switch which typedef'ed my vector class name to std::vector if in release or
used the derived class if in debug. Does that sound reasonable? Is there
an easier and more common way?

[Cy Edmunds]

"Biff" <fk**@fcvie.com > wrote in message
news:36******** *****@individua l.net...

Is there a common way to check for vector indexes being in bounds? My
version of the STL has no such check, even in debug builds. I was
considering deriving a class from Vector with its own operator[], and
using that in my code instead of std::vector. Then I'd use an #ifdef
_DEBUG switch which typedef'ed my vector class name to std::vector if in
release or used the derived class if in debug. Does that sound
reasonable? Is there an easier and more common way?

Look at the function "at" which should already be in your std::vector. I
think it does what you want.

--
Cy
http://home.rochester.rr.com/cyhome/

[Mike Wahler]

"Biff" <fk**@fcvie.com > wrote in message
news:36******** *****@individua l.net...

Is there a common way to check for vector indexes being in bounds? My
version of the STL has no such check, even in debug builds. I was
considering deriving a class from Vector with its own operator[], and using that in my code instead of std::vector. Then I'd use an #ifdef _DEBUG
switch which typedef'ed my vector class name to std::vector if in release or used the derived class if in debug. Does that sound reasonable? Is there
an easier and more common way?

std::vector::at ()

The argument is the same you'd use for operator[](),
but if given an out-of-bounds value, throws an exception
(of type 'std::out_of_ra nge').

-Mike

[Stephen Howe]

> Is there a common way to check for vector indexes being in bounds? My

version of the STL has no such check, even in debug builds. I was
considering deriving a class from Vector with its own operator[], and
using that in my code instead of std::vector. Then I'd use an #ifdef
_DEBUG switch which typedef'ed my vector class name to std::vector if in
release or used the derived class if in debug. Does that sound
reasonable? Is there an easier and more common way?

Use member function at()

I sometimes use the following for vector and deque:

#if defined(_DEBUG)
#define AT(x) at(x)
#else
#define AT(x) operator[](x)
#endif

and then have something like

std::vector<int > v;

int i = v.AT(0);

For debug builds, access is ranged-checked
For release builds, access is not ranged-checked

Of course there is nothing to stop you from doing

int j = v[1];
int k = v.at(2);

when you defiintely want no range checking or range checking.

Stephen Howe

[E. Robert Tisdale]

Biff wrote:

Is there a common way to check for vector indexes being in bounds?
You could use member function

reference
at(size_type __n) { _M_range_check( __n);
return (*this)[__n]; }
const_reference
at(size_type __n) const { _M_range_check( __n);
return (*this)[__n]; }

but that throws an exception and is *not* appropriate
if you are trying to trap programming errors (bugs).
My version of the STL has no such check, even in debug builds.
I was considering deriving a class from Vector with its own operator[]
and using that in my code instead of std::vector.
Then I'd use an #ifdef _DEBUG switch
which typedef'ed my vector class name to std::vector
if in release or used the derived class if in debug.
Does that sound reasonable?
It sounds very reasonable.
Is there an easier and more common way?

My GNU C++ compiler defines members:

reference
operator[](size_type __n) { return *(begin() + __n); }

const_reference
operator[](size_type __n) const { return *(begin() + __n); }

in /usr/include/c++/3.4.0/bits/stl_vector.h
You could redefine them:

reference
operator[](size_type __n) {
assert(__n < this->size()); return *(begin() + __n); }

const_reference
operator[](size_type __n) const {
assert(__n < this->size()); return *(begin() + __n); }

Anyway, you should check your implementation.
You might find that this has already been done for you.