C++Talk.NET Forum Index C++Talk.NET
C++ language newsgroups
 
Archives   FAQFAQ   SearchSearch   MemberlistMemberlist   UsergroupsUsergroups   RegisterRegister 
 ProfileProfile   Log in to check your private messagesLog in to check your private messages   Log inLog in 

Catching vector index out of bounds

 
Post new topic   Reply to topic    C++Talk.NET Forum Index -> C++ language (comp.lang.c++)
View previous topic :: View next topic  
Author Message
Biff
Guest





PostPosted: Sun Jan 30, 2005 5:24 pm    Post subject: Catching vector index out of bounds Reply with quote



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?


Back to top
Cy Edmunds
Guest





PostPosted: Sun Jan 30, 2005 5:27 pm    Post subject: Re: Catching vector index out of bounds Reply with quote



"Biff" <fksl (AT) fcvie (DOT) com> wrote

Quote:
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/



Back to top
Mike Wahler
Guest





PostPosted: Sun Jan 30, 2005 7:12 pm    Post subject: Re: Catching vector index out of bounds Reply with quote




"Biff" <fksl (AT) fcvie (DOT) com> wrote

Quote:
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



Back to top
Stephen Howe
Guest





PostPosted: Mon Jan 31, 2005 3:09 am    Post subject: Re: Catching vector index out of bounds Reply with quote

Quote:
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



Back to top
E. Robert Tisdale
Guest





PostPosted: Mon Jan 31, 2005 5:55 am    Post subject: Re: Catching vector index out of bounds Reply with quote

Biff wrote:

Quote:
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).

Quote:
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.

Quote:
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.

Back to top
Display posts from previous:   
Post new topic   Reply to topic    C++Talk.NET Forum Index -> C++ language (comp.lang.c++) All times are GMT
Page 1 of 1

 
Jump to:  
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum


Powered by phpBB © 2001, 2006 phpBB Group
SEO toolkit © 2004-2006 webmedic.