By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
445,655 Members | 1,005 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 445,655 IT Pros & Developers. It's quick & easy.

Catching vector index out of bounds

P: n/a
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?
Jul 23 '05 #1
Share this Question
Share on Google+
4 Replies


P: n/a
"Biff" <fk**@fcvie.com> wrote in message
news:36*************@individual.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/
Jul 23 '05 #2

P: n/a

"Biff" <fk**@fcvie.com> wrote in message
news:36*************@individual.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_range').

-Mike
Jul 23 '05 #3

P: n/a
> 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
Jul 23 '05 #4

P: n/a
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.
Jul 23 '05 #5

This discussion thread is closed

Replies have been disabled for this discussion.