On Dec 20, 6:45 pm, n.torrey.pi...@gmail.com wrote:
Quote:
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[i]);
>
// pr - either std::pair 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
*/
accessing contiguous std::vector elements as a pair 
