«

Hi all!

Given:
std::vector<TYPE> v;
void process(size_t count, TYPE* data);

Is there any problem if I do

if (!v.empty())
{
std::vector<TYPE>::reference r = *v.begin();
// or
r = v[0];
// or
r = v.at(0);
process_raw(v.size(), &p);
}

?

(This is what I do all the time to interface with lower-level code,
but I've always been wondering if there's some issue in doing things
like these).

TIA,

Goran.

On Sep 7, 3:26*pm, Goran Pusic <gor...@cse-semaphore.com> wrote:
> Hi all!
>
> Given:
> std::vector<TYPE> v;
> void process(size_t count, TYPE* data);
>
> Is there any problem if I do
>
> if (!v.empty())
> {
> * std::vector<TYPE>::reference r = *v.begin();
> * // or
> * r = v[0];
> * // or
> * r = v.at(0);
> * process_raw(v.size(), &p);
>
> }
>
> ?

No problem at all. It was for supporting code like this that
std::vector always has had the guarantee that it uses contiguous
storage for it elements.

Bart v Ingen Schenau

* Bart van Ingen Schenau, on 07.09.2010 15:42:
> On Sep 7, 3:26 pm, Goran Pusic<gor...@cse-semaphore.com> wrote:
>> Hi all!
>>
>> Given:
>> std::vector<TYPE> v;
>> void process(size_t count, TYPE* data);
>>
>> Is there any problem if I do
>>
>> if (!v.empty())
>> {
>> std::vector<TYPE>::reference r = *v.begin();
>> // or
>> r = v[0];
>> // or
>> r = v.at(0);
>> process_raw(v.size(),&p);
>>
>> }
>>
>> ?
>
> No problem at all. It was for supporting code like this that
> std::vector always has had the guarantee that it uses contiguous
> storage for it elements.

Not "always"; it got that guarantee in C++03.


Cheers,

- Alf

--
blog at <url: http://alfps.wordpress.com>

* Marcel Müller, on 07.09.2010 15:49:
> Goran Pusic wrote:
>> Hi all!
>>
>> Given:
>> std::vector<TYPE> v;
>> void process(size_t count, TYPE* data);
>>
>> Is there any problem if I do
>>
>> if (!v.empty())
>> {
>> std::vector<TYPE>::reference r = *v.begin();
>> // or
>> r = v[0];
>> // or
>> r = v.at(0);
>> process_raw(v.size(), &p);
>
> p is undefined. You probably mean
> process_raw(v.size(), &*v.begin());

process_raw is undefined. You probably mean

process( v.size, &r );


>> }
>
> I remember that we had the same discussion some time ago. AFAIR the result was
> that the storage layout of vector is not guaranteed by the standard in this way,
> but this is more an accident rather then intensionally.

A std::vector is guaranteed to have contiguous storage, per C++03.


Cheers & hth.,

- Alf

--
blog at <url: http://alfps.wordpress.com>

Goran Pusic wrote:
>
> Given:
> std::vector<TYPE> v;
> void process(size_t count, TYPE* data);
>
> Is there any problem if I do
>
> if (!v.empty())
> {
> std::vector<TYPE>::reference r = *v.begin();
> // or
> r = v[0];
> // or
> r = v.at(0);
> process_raw(v.size(), &p);
> }
>
> ?

Yes, the technique it is perfectly valid.

You can simply use `&v.front()` to obtain the pointer to the first
element of the raw array, instead of going through the iterators and all
these intermediate dereferences and address-takings.

Also, be aware of specialized versions of `std::vector<>`, like
`std::vector<bool>` for example, which will not work with this technique
(it stores bool values in a packed array of bits, providing no direct
access to the raw array).


--
Best regards,
Andrey Tarasevich