Re: Test - Ignore : Plain Text UUENCODE

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
thevector.
//---------------------------------------------------------------------------------
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
thevector or // to the location succeeding an empty vector. You
should alwayscompare // the value returned with vector::end to
ensure it is valid. // // end : A random-access iterator to the end of the
vector object. Youshould // 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 isequivalent; // 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 thelatter // 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
ofelements 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 thecontainer's size //
is larger than the requested size, the elements closest to the end ofthe
// 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
fromspecified // 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
emptyvector. // // 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 5elements
//---------------------------------------------------------------------------------
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
locationsucceeding // the last element in a reversed vector (the
location that hadpreceded 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
constructthe // 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