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