accessing contiguous std::vector elements as a pair

[n.torrey.pines]

I'd like to be able to view two contiguous elements of a vector as a
pair.

Assuming I'm not accessing the last element, of course, and the
element type is not bool, when is it safe to do so, from the language
definition point of view?

const pr& p = *(const pr*)(&v);

// pr - either std:air or hand-defined pair of elements
// v - vector instance
// i + 1 < v.size()

 

[Salt_Peter]

I'd like to be able to view two contiguous elements of a vector as a
pair.

Assuming I'm not accessing the last element, of course, and the
element type is not bool, when is it safe to do so, from the language
definition point of view?

const pr& p = *(const pr*)(&v);

// pr - either std:air or hand-defined pair of elements
// v - vector instance
// i + 1 < v.size()

When is it safe to do so? whenever you take the appropriate
precautions.
In this case, std::vectors have an at(...) member function that throws
an out_of_range exception should someone accidentally attempt to
access something out of bounds. There you go - problem solved.

Using pointers for that has no safety and usually demands considerably
more work (ie: maintenance).

In the following, i'm not too worried about getting main's for-loop
wrong, it'll throw if i do. Try it.

#include <iostream>
#include <vector>
#include <stdexcept>

template< typename T >
class Container
{
std::vector< T > m_v;
public:
// default ctor
Container() : m_v() { }
Container(const size_t sz, const T& t) : m_v(sz, t) { }
// member functions
void push_back(const T& t) { m_v.push_back(t); }
void showpair(const size_t index) const
{
std::cout << "m_v[" << index << "] ";
std::cout << m_v.at(index);
std::cout << "\tm_v[" << index + 1 << "] ";
std::cout << m_v.at(index + 1);
std::cout << std::endl;
}
size_t size() const { return m_v.size(); }
};

int main()
{
try
{
Container< int > container(5, 99);
container.push_back(77);
// use i < container.size() to throw an exception
for(size_t i = 0; i < container.size() - 1; ++i)
{
container.showpair(i);
}
}
catch(const std::exception& e)
{
std::cout << "\nError: ";
std::cout << e.what() << std::endl;
}
}

/*
m_v[0] 99 m_v[1] 99
m_v[1] 99 m_v[2] 99
m_v[2] 99 m_v[3] 99
m_v[3] 99 m_v[4] 99
m_v[4] 99 m_v[5] 77
*/

 

[n.torrey.pines]

void showpair(const size_t index) const
{
std::cout << "m_v[" << index << "] ";
std::cout << m_v.at(index);
std::cout << "\tm_v[" << index + 1 << "] ";
std::cout << m_v.at(index + 1);
std::cout << std::endl;
}

This is a joke, right?

If not, I didn't mean "view" in the common sense, and "at()" doesn't
add any safety if the index is already guaranteed to be in [0 ..
size()-2]

 

[James Kanze]

I'd like to be able to view two contiguous elements of a vector as a
pair.

Assuming I'm not accessing the last element, of course, and the
element type is not bool, when is it safe to do so, from the language
definition point of view?

const pr& p = *(const pr*)(&v);

// pr - either std:air or hand-defined pair of elements
// v - vector instance
// i + 1 < v.size()

Anytime your implementation gives you a special guarantee that
this will work. It's undefined behavior according to the
standard (even though it's likely to work most of the time in a
lot of implementations).