is &(vector[0]) always valid?

[John Salmon]

I was under the impression that the following was always valid:

std::vector<Tv;
..
T *p = &(v[0]);

But I was recently told that care was needed in case the vector was
empty, i.e., when v.size() == 0.

I'm hoping that the above expression is fine, even if v is empty, but
that if you try to dereference p, you're in trouble.

If the above isn't ok, I'd have to write:

T *p = (v.size()!=0)? &(v[0]) : 0;

I took a look in the C++98 standard, and couldn't find anything to
confirm my hope. I see from Table 68 that the expression has the
"operationa l sematics" of

&(*(v.begin( ) + 0))

which sure *seems* like it might in turn be "operationa lly equivalent"
to v.begin(), which sure seems safe, even for an empty vector. But I
now feel myself to be on very thin ice.

So, can I write:

T *p = &(v[0]);

or do I have to write:

T *p = (v.size()!=0)? &(v[0]) : 0;

Thanks,
John Salmon

---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:st*****@ ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]

[Gianni Mariani]

John Salmon wrote:

I was under the impression that the following was always valid:

std::vector<Tv;
.
T *p = &(v[0]);

But I was recently told that care was needed in case the vector was
empty, i.e., when v.size() == 0.

I'm hoping that the above expression is fine, even if v is empty, but
that if you try to dereference p, you're in trouble.

It may work on your platform, however the C++ standard says it's
undefined. Hence, it may work for you today but it may also break tomorrow.

>
If the above isn't ok, I'd have to write:

T *p = (v.size()!=0)? &(v[0]) : 0;

Right.

[Alan Johnson]

John Salmon wrote:

I was under the impression that the following was always valid:

std::vector<Tv;
.
T *p = &(v[0]);

But I was recently told that care was needed in case the vector was
empty, i.e., when v.size() == 0.

I'm hoping that the above expression is fine, even if v is empty, but
that if you try to dereference p, you're in trouble.

If the above isn't ok, I'd have to write:

T *p = (v.size()!=0)? &(v[0]) : 0;

I took a look in the C++98 standard, and couldn't find anything to
confirm my hope. I see from Table 68 that the expression has the
"operationa l sematics" of

&(*(v.begin( ) + 0))

which sure *seems* like it might in turn be "operationa lly equivalent"
to v.begin(), which sure seems safe, even for an empty vector. But I
now feel myself to be on very thin ice.

So, can I write:

T *p = &(v[0]);

or do I have to write:

T *p = (v.size()!=0)? &(v[0]) : 0;

Thanks,
John Salmon

v[0] is NOT valid for an empty vector, and therefore &v[0] is not valid
either. You are right about the operational semantics, but neither is
that expression valid. If the vector is empty, then begin() == end(),
and you are therefore "dereferenc ing" the end() iterator.

As for the alternate expression you propose, using empty() rather than
size() would be more idiomatic, and might be more efficient, depending
on the implementation:

T *p = v.empty() ? 0 : &(v[0]) ;

--
Alan Johnson

---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:st*****@ ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]

[Carl Barron]

In article <m3************ @river.fishnet> , John Salmon
<js*****@thesal mons.orgwrote:

I was under the impression that the following was always valid:

std::vector<Tv;
.
T *p = &(v[0]);

But I was recently told that care was needed in case the vector was
empty, i.e., when v.size() == 0.

its not valid if v.size()==0.
template <class T,class A>
inline T *data(std::vect or<T,A&v)
{
return v.empty() ? 0: &v[0];
}
is an easy work around. Recent drafts of the standard provide
vector with a data() member function which does this, but your
implementation probably does not.

---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:st*****@ ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]

[Roland Pibinger]

On Sat, 20 Jan 2007 07:21:08 GMT, John Salmon wrote:

>So, can I write:

T *p = &(v[0]);

or do I have to write:

T *p = (v.size()!=0)? &(v[0]) : 0;

What would be the address of the first element of an empty vector?

---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:st*****@ ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]

[Kai-Uwe Bux]

John Salmon wrote:

>
I was under the impression that the following was always valid:

std::vector<Tv;
.
T *p = &(v[0]);

But I was recently told that care was needed in case the vector was
empty, i.e., when v.size() == 0.

I'm hoping that the above expression is fine, even if v is empty, but
that if you try to dereference p, you're in trouble.

If v is empty, once you evaluate v[0] you have undefined behavior. More
importantly, an implementation of std::vector<is perfectly free and maybe
even well-advised to do something like:

T& operator[] ( size_type i ) {
assert( i < this->size() );
return( this->data[i] );
}

Because of the assert(), your program could crash depending on compilation
options.

If the above isn't ok, I'd have to write:

T *p = (v.size()!=0)? &(v[0]) : 0;

I took a look in the C++98 standard, and couldn't find anything to
confirm my hope. I see from Table 68 that the expression has the
"operationa l sematics" of

&(*(v.begin( ) + 0))

which sure *seems* like it might in turn be "operationa lly equivalent"
to v.begin(), which sure seems safe, even for an empty vector. But I
now feel myself to be on very thin ice.

So, can I write:

T *p = &(v[0]);

or do I have to write:

T *p = (v.size()!=0)? &(v[0]) : 0;

Why do you insist on using T* anyway? What is the reason not to use
std::vector<T>: :iterator?
Best

Kai-Uwe Bux

---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:st*****@ ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]

[Andrew Koenig]

"John Salmon" <js*****@thesal mons.orgwrote in message
news:m3******** ****@river.fish net...

I was under the impression that the following was always valid:

std::vector<Tv;

T *p = &(v[0]);

But I was recently told that care was needed in case the vector was
empty, i.e., when v.size() == 0.

Whoever told you that is correct.

I'm hoping that the above expression is fine, even if v is empty, but
that if you try to dereference p, you're in trouble.

Sorry to dash your hopes, but...

If the above isn't ok, I'd have to write:

T *p = (v.size()!=0)? &(v[0]) : 0;

Right.

>
I took a look in the C++98 standard, and couldn't find anything to
confirm my hope. I see from Table 68 that the expression has the
"operationa l sematics" of

&(*(v.begin( ) + 0))

which sure *seems* like it might in turn be "operationa lly equivalent"
to v.begin(), which sure seems safe, even for an empty vector. But I
now feel myself to be on very thin ice.

You are. v.begin() + 0 is always equivalent to v.begin(), but &(*v.begin() )
is undefined if v is empty.

---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:st*****@ ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]

[Francis Glassborow]

In article <m3************ @river.fishnet> , John Salmon
<js*****@thesal mons.orgwrites

>I was under the impression that the following was always valid:

std::vector<Tv ;
.
T *p = &(v[0]);

But I was recently told that care was needed in case the vector was
empty, i.e., when v.size() == 0.

You were correctly informed. The problem is that v[0] has undefined
behaviour if there are no elements. That means that &(v[0]) has
undefined behaviour. This is not that unreasonable because an empty
vector does not have a location for any element so there will be no
address.

Changing this would have required a special rule for &(v[0]). Instead
you must write something like:

T *p = v.size() ? &(v[0]) : 0;

If there is any possibility that v is an empty vector. (There are
several variations on the above definition but I tend to use a limited
subset of the member functions of vector rather than remember the exact
spelling of all of them.)
--
Francis Glassborow ACCU
Author of 'You Can Do It!' and "You Can Program in C++"
see http://www.spellen.org/youcandoit
For project ideas and contributions: http://www.spellen.org/youcandoit/projects

---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:st*****@ ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]

[James Kanze]

John Salmon wrote:

I was under the impression that the following was always valid:

std::vector<Tv;
.
T *p = &(v[0]);

But I was recently told that care was needed in case the vector was
empty, i.e., when v.size() == 0.

I'm hoping that the above expression is fine, even if v is empty,

It's not. It's undefined behavior, and will core dump on some
implementations . (It core dumps with g++ 4.0.1, for example, or
with VC++ 8.)

but that if you try to dereference p, you're in trouble.

If the above isn't ok, I'd have to write:

T *p = (v.size()!=0)? &(v[0]) : 0;

I took a look in the C++98 standard, and couldn't find anything to
confirm my hope. I see from Table 68 that the expression has the
"operationa l sematics" of

&(*(v.begin( ) + 0))

No. The expression a[n] is the equivalent of *(v.begin() + 0)
(which is presumably the equivalent of *v.begin()). If
v.begin() == v.end(), however, *v.begin() is undefined behavior.

which sure *seems* like it might in turn be "operationa lly equivalent"
to v.begin(), which sure seems safe, even for an empty vector. But I
now feel myself to be on very thin ice.

I'd say that the ice has already broken. Your code causes a
run-time error (core dump, or its moral equivalent under
Windows) with two of the three compilers I regularly use.

So, can I write:

T *p = &(v[0]);

or do I have to write:

T *p = (v.size()!=0)? &(v[0]) : 0;

The latter.

Given the particular guarantee for std::vector, I wonder if an
additional member function, data() might not be in order. A
function which could be required to return a null pointer if the
vector is empty.

--
James Kanze (Gabi Software) email: ja*********@gma il.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]
---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:st*****@ ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]

[whyglinux]

John Salmon wrote:

I was under the impression that the following was always valid:

std::vector<Tv;
.
T *p = &(v[0]);

But I was recently told that care was needed in case the vector was
empty, i.e., when v.size() == 0.

I'm hoping that the above expression is fine, even if v is empty, but
that if you try to dereference p, you're in trouble.

If the above isn't ok, I'd have to write:

T *p = (v.size()!=0)? &(v[0]) : 0;

I took a look in the C++98 standard, and couldn't find anything to
confirm my hope. I see from Table 68 that the expression has the
"operationa l sematics" of

&(*(v.begin( ) + 0))

which sure *seems* like it might in turn be "operationa lly equivalent"
to v.begin(), which sure seems safe, even for an empty vector. But I
now feel myself to be on very thin ice.

So, can I write:

T *p = &(v[0]);

or do I have to write:

T *p = (v.size()!=0)? &(v[0]) : 0;

Thanks,
John Salmon

---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:st*****@ ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]

Yes, it's undefined.

v[0] is equivalent to *v.begin(). Whether v is an empty vector or not,
v.begin() returns a valid iterator. But if v is empty, v.begin(), like
v.end(), is not a valid dereferenceable iterator, so *v.begin() is
undefined.

Note though, &(*(v.begin( ) + 0)) is not, as you said, "operationa lly
equivalent" to v.begin() because v.begin() returns an object of the
vector<T>'s iterator type while &(*(v.begin( ) + 0)) should return a
type of pointer to T (since operator * is overloaded here), and the
iterator type needs not to be the same as a pointer to T.

---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:st*****@ ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]