Test - Ignore : Plain Text Mime Quoted Printable
std::vector<CPoint> m_Pts;
CPoint Pt(2, 4);
CPoint& rPt = Pt;
int size_type;
=
//-----------------------------------------------------------------------=
----------
// Fill Vector
=
//-----------------------------------------------------------------------=
----------
for (UINT i = 1; i < 11; i++)
{
CPoint Pt;
Pt.x = i;
Pt.y = i;
m_Pts.push_back(Pt);
}
=
//-----------------------------------------------------------------------=
----------
// at : Returns a reference to the element at a specified location in =
the vector.
=
//-----------------------------------------------------------------------=
----------
for (UINT i = 0; i < 10; i++)
{
CPoint& rPt = m_Pts.at(i);
TRACE("Pt[%d] Pt.x %d, Pt.y %d\n", i, rPt.x, rPt.y);
}
=
//-----------------------------------------------------------------------=
----------
// begin : A random-access iterator addressing the first element in the =
vector or
// to the location succeeding an empty vector. You should =
always compare
// the value returned with vector::end to ensure it is valid.
//
// end : A random-access iterator to the end of the vector object. You =
should
// compare the value returned to vector::begin to ensure it is =
valid.
//
// *c1_cIter = 200; Error. c1_cIter is constant.
=
//-----------------------------------------------------------------------=
----------
m_Pts.resize(20);
std::vector<CPoint>::const_iterator m_cIter;
std::vector<CPoint>::iterator m_Iter;
m_Iter = m_Pts.begin();
TRACE("begin: Pt.x %d, Pt.y %d\n", m_Iter->x, m_Iter->y);
rPt = m_Pts.front();
TRACE("front: Pt.x %d, Pt.y %d\n", rPt.x, rPt.y);
//Gives different results.
// end does not seem to be in the list.
m_Iter = m_Pts.end();
TRACE("end: Pt.x %d, Pt.y %d\n", m_Iter->x, m_Iter->y);
rPt = m_Pts.back();
TRACE("back: Pt.x %d, Pt.y %d\n", rPt.x, rPt.y);
for (UINT i = 0; i < m_Pts.size(); i++)
{
CPoint& rPt = m_Pts.at(i);
TRACE("Pt[%d] Pt.x %d, Pt.y %d\n", i, rPt.x, rPt.y);
}
for(m_Iter = m_Pts.begin(); m_Iter != m_Pts.end(); ++m_Iter)
{
// It is more common to write m_Iter->x. The syntax (*m_Iter).x is =
equivalent;
// it dereferences the iterator and then selects a member using the =
dot. The
// -> syntax is a shorthand for this but doesn't require the parens =
the latter
// needs due to the relative precedence of the two operators it uses.
// TRACE("Pt Pt.x %d, Pt.y %d\n", (*m_Iter).x, (*m_Iter).y);
int index = m_Iter - m_Pts.begin();
TRACE("Pt[%d] Pt.x %d, Pt.y %d\n", index, m_Iter->x, m_Iter->y);
}
=
//-----------------------------------------------------------------------=
----------
// front : Returns a reference to the first element in a vector.
//
// back : Returns a reference to the last element of the vector.
=
//-----------------------------------------------------------------------=
----------
rPt = m_Pts.front();
TRACE("front: Pt.x %d, Pt.y %d\n", rPt.x, rPt.y);
rPt = m_Pts.back();
TRACE("back: Pt.x %d, Pt.y %d\n", rPt.x, rPt.y);
rPt = m_Pts.front();
TRACE("front: Pt.x %d, Pt.y %d\n", rPt.x, rPt.y);
rPt = m_Pts.back();
TRACE("back: Pt.x %d, Pt.y %d\n", rPt.x, rPt.y);
=
//-----------------------------------------------------------------------=
----------
// insert : Inserts an element or a number of elements or a range of =
elements into
// the vector at a specified position.
//
// Optional : m_Pts.insert(m_Pts.begin(), 1, 2);
// m_Pts.insert(m_Pts.begin(), 2);
//
=
//-----------------------------------------------------------------------=
----------
TRACE("insert\n");
TRACE("before\n");
size_type = m_Pts.size();
TRACE("size : %d\n", size_type);
for (UINT i = 0; i < m_Pts.size(); i++)
{
CPoint& rPt = m_Pts.at(i);
TRACE("Pt[%d] Pt.x %d, Pt.y %d\n", i, rPt.x, rPt.y);
}
m_Pts.insert(m_Pts.begin(), CPoint(999,888));
TRACE("After\n");
size_type = m_Pts.size();
TRACE("size : %d\n", size_type);
for (UINT i = 0; i < m_Pts.size(); i++)
{
CPoint& rPt = m_Pts.at(i);
TRACE("Pt[%d] Pt.x %d, Pt.y %d\n", i, rPt.x, rPt.y);
}
=
//-----------------------------------------------------------------------=
----------
// size : Returns the number of elements in the vector.
//
// max_size: The maximum size of the vector.
//
// capacity : the number of elements that the vector could contain =
without
// allocating more storage.
=
//-----------------------------------------------------------------------=
----------
size_type = m_Pts.size();
TRACE("size : %d\n", size_type);
size_type = m_Pts.capacity();
TRACE("capacity : %d\n", size_type);
size_type = m_Pts.max_size();
TRACE("max_size : %d\n", size_type);
=
//-----------------------------------------------------------------------=
----------
// resize : Specifies a new size for a vector.
//
// If the container's size is less than the requested size, _Newsize, =
elements are
// added to the vector until it reaches the requested size. If the =
container's size
// is larger than the requested size, the elements closest to the end =
of the
// container are deleted until the container reaches the size _Newsize. =
=
//-----------------------------------------------------------------------=
----------
TRACE("resize - grow\n");
m_Pts.resize(20);
size_type = m_Pts.size();
TRACE("size : %d\n", size_type);
rPt = m_Pts.front();
TRACE("front: Pt.x %d, Pt.y %d\n", rPt.x, rPt.y);
rPt = m_Pts.back();
TRACE("back: Pt.x %d, Pt.y %d\n", rPt.x, rPt.y);
TRACE("resize - shrink\n");
m_Pts.resize(5);
size_type = m_Pts.size();
TRACE("size : %d\n", size_type);
rPt = m_Pts.front();
TRACE("front: Pt.x %d, Pt.y %d\n", rPt.x, rPt.y);
rPt = m_Pts.back();
TRACE("back: Pt.x %d, Pt.y %d\n", rPt.x, rPt.y);
=
//-----------------------------------------------------------------------=
----------
// reserve : Reserves a minimum length of storage for a vector object, =
allocating
// space if necessary.
// *Changes the capacity.
=
//-----------------------------------------------------------------------=
----------
TRACE("reserve\n");
TRACE("Before\n");
size_type = m_Pts.size();
TRACE("size : %d\n", size_type);
size_type = m_Pts.capacity();
TRACE("capacity : %d\n", size_type);
size_type = m_Pts.max_size();
TRACE("max_size : %d\n", size_type);
m_Pts.reserve(100);
TRACE("After\n");
size_type = m_Pts.size();
TRACE("size : %d\n", size_type);
size_type = m_Pts.capacity();
TRACE("capacity : %d\n", size_type);
size_type = m_Pts.max_size();
TRACE("max_size : %d\n", size_type);
rPt = m_Pts.front();
TRACE("front: Pt.x %d, Pt.y %d\n", rPt.x, rPt.y);
rPt = m_Pts.back();
TRACE("back: Pt.x %d, Pt.y %d\n", rPt.x, rPt.y);
=
//-----------------------------------------------------------------------=
----------
// pop_back : Deletes the element at the end of the vector.
=
//-----------------------------------------------------------------------=
----------
TRACE("pop_back\n");
TRACE("Before\n");
rPt = m_Pts.back();
TRACE("back: Pt.x %d, Pt.y %d\n", rPt.x, rPt.y);
size_type = m_Pts.size();
TRACE("size : %d\n", size_type);
m_Pts.pop_back();
TRACE("After\n");
rPt = m_Pts.back();
TRACE("back: Pt.x %d, Pt.y %d\n", rPt.x, rPt.y);
size_type = m_Pts.size();
TRACE("size : %d\n", size_type);
=
//-----------------------------------------------------------------------=
----------
// push_back : Adds elements to the end
=
//-----------------------------------------------------------------------=
----------
TRACE("push_back\n");
TRACE("Before\n");
rPt = m_Pts.back();
TRACE("back: Pt.x %d, Pt.y %d\n", rPt.x, rPt.y);
size_type = m_Pts.size();
TRACE("size : %d\n", size_type);
m_Pts.push_back(CPoint(88,99));
TRACE("After\n");
rPt = m_Pts.back();
TRACE("back: Pt.x %d, Pt.y %d\n", rPt.x, rPt.y);
size_type = m_Pts.size();
TRACE("size : %d\n", size_type);
=
//-----------------------------------------------------------------------=
----------
// erase : Removes an element or a range of elements in a vector from =
specified
// positions.
=
//-----------------------------------------------------------------------=
----------
TRACE("erase\n");
m_Pts.erase(m_Pts.begin(), m_Pts.begin()+1);
for (UINT i = 0; i < m_Pts.size(); i++)
{
CPoint& rPt = m_Pts.at(i);
TRACE("Pt[%d] Pt.x %d, Pt.y %d\n", i, rPt.x, rPt.y);
}
size_type = m_Pts.size();
TRACE("size : %d\n", size_type);
=
//-----------------------------------------------------------------------=
----------
// assign: Erases a vector and copies the specified elements to the =
empty vector.
//
// m_Pts2.assign(m_Pts.begin(), m_Pts.end()); : Copies m_Pts into =
m_Pts2
//
// m_Pts3.assign(5, CPoint(66,77)); : Copies CPoint 5 times into first =
5 elements
=
//-----------------------------------------------------------------------=
----------
std::vector<CPoint> m_Pts2;
std::vector<CPoint> m_Pts3;
TRACE("assign - part 1.\n");
m_Pts2.assign(m_Pts.begin(), m_Pts.end());
for(UINT nItem = 0; nItem < m_Pts2.size(); nItem++)
{
CPoint& pt = m_Pts2.at(nItem);
TRACE("Pt[%d] Pt.x %d, Pt.y %d\n", nItem, pt.x, pt.y);
}
TRACE("assign - part 2.\n");
m_Pts3.assign(5, CPoint(66,77));
for(UINT nItem = 0; nItem < m_Pts3.size(); nItem++)
{
CPoint& pt = m_Pts3.at(nItem);
TRACE("Pt[%d] Pt.x %d, Pt.y %d\n", nItem, pt.x, pt.y);
}
=
//-----------------------------------------------------------------------=
----------
// swap : Exchanges the elements of two vectors.
=
//-----------------------------------------------------------------------=
----------
TRACE("swap\n");
m_Pts2.swap(m_Pts3);
for(UINT nItem = 0; nItem < m_Pts2.size(); nItem++)
{
CPoint& pt = m_Pts2.at(nItem);
TRACE("Pt[%d] Pt.x %d, Pt.y %d\n", nItem, pt.x, pt.y);
}
=
//-----------------------------------------------------------------------=
----------
//rbegin : Returns an iterator to the first element in a reversed =
vector.
=
//-----------------------------------------------------------------------=
----------
/*
std::vector<CPoint>::reverse_iterator m_rIter;
for(m_rIter = m_Pts.rbegin(); m_rIter < m_Pts2.size(); m_rIter++)
{
CPoint& pt = m_Pts2.at(nItem);
TRACE("Pt[%d] Pt.x %d, Pt.y %d\n", nItem, pt.x, pt.y);
}
*/
=
//-----------------------------------------------------------------------=
----------
//rend : A reverse random-access iterator that addresses the location =
succeeding
// the last element in a reversed vector (the location that had =
preceded the
// first element in the unreversed vector).
=
//-----------------------------------------------------------------------=
----------
/*
for(m_rIter = m_Pts.rbegin(); rIter < m_Pts2.size(); rIter++)
{
CPoint& pt = m_Pts2.at(nItem);
TRACE("Pt[%d] Pt.x %d, Pt.y %d\n", nItem, pt.x, pt.y);
}
*/
=
//-----------------------------------------------------------------------=
----------
// clear : Erases the elements of the vector.
//
// empty : Tests if the vector is empty.
=
//-----------------------------------------------------------------------=
----------
if( m_Pts.empty())
{
TRACE("Vector is Empty\n");
}else{
TRACE("Vector is Not Empty\n");
}
m_Pts.clear();
if( m_Pts.empty())
{
TRACE("Vector is Empty\n");
}else{
TRACE("Vector is Not Empty\n");
}
=
//-----------------------------------------------------------------------=
----------
// get_allocator : Returns a copy of the allocator object used to =
construct the
// vector.
=
//-----------------------------------------------------------------------=
----------
// m_Pts.get_allocator();
// The following lines declare objects that use the default =
allocator.
// vector<int> v1;
// vector<int, allocator<int> > v2 = vector<int, allocator<int> =
(allocator<int>( )) ;
// v3 will use the same allocator class as v1
// vector <int> v3( v1.get_allocator( ) );
// vector<int>::allocator_type xvec = v3.get_allocator( );
// You can now call functions on the allocator class used by vec