On Dec 20, 6:45 pm, n.torrey.pi...@ gmail.com wrote:
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.showp air(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
*/
