Re: possible to catch invalidated ref to vector entry?
On May 22, 1:09 am, vava...@cpu111.math.uwaterloo.ca (Stephen Vavasis)
wrote:
I wrote my own template class Myvector<T> quite similar to std::vector<T> with few features I needed. It has operator[] that
returns a T& and also const operator[] that returns a const T&. Twice in my code I found the following buggy construction.
Suppose "MyStruct" is a structure type with a bool field called "updated". Suppose that variable "vec" has type
Myvector<MyStruct>. Here is the buggy code:
MyStruct& d = vec[i];
// intermediate statements that might execute vec.push_back()
// and hence may invalidate d.
d.updated = true;
The problem with this code is that, not only is it buggy, but in most cases it works just fine so that the bug is hard to find.
The question is whether it is possible to detect this error either at compile time or run time. In other words, is there some
trick with automatic type conversions, etc., so that vec[i].updated=true will always work as expected, but the above sequence,
in which a named reference is assigned to vec[i] and then used later will never work.
Thanks,
Steve Vavasis
vava...@math.uwaterloo.ca
If you define d as a reference then no, a simple reference cannot know
that the referee has been destructed or changed in any way. But if
your class is actually a standard container, I mean, if it has an
iterator, and you use iterators in such cases instead of a simple
reference:
auto d = vec.begin()+i; // or if you don't use c++0X,
Myvector<T>::iterator = vec.begin()+i;
// intermediate statements that might execute vec.push_back()
// and hence may invalidate d.
d->updated = true;
Then, you could add code to your iterator class (at least on debug
version) that will verify such bugs, at the cost of affecting the
performance somehow.
For example, the container will have an integer counter that increases
every time an operation that invalidates iterators is executed. Then
only iterators that were created for the current counter are valid.
Changes to your code in general terms:
template< typename T >
class Myvector
{
....
private: long m_IteratorValidityCounter;
private: void increaseIteratorValidityCounter()
{
++m_IteratorValidityCounter;
}
private: void AssertValidIterator( long r )
{
if( r != m_IteratorValidityCounter ) {
}
public: iterator begin()
{
return iterator( ..., m_IteratorValidityCounter );
}
public: push_back( ... )
{
increaseIteratorValidityCounter();
...
}
};
template< typename T >
class Myvector::iterator
{
private: m_ValidityCounter;
private: Myvector<T>* m_Container;
public: iterator( ..., long r )
:
....
m_ValidityCounter(r)
{...}
public: T* operator->() const
{
m_Container->AssertValidIterator( m_ValidityCounter );
return ...;
}
};
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]