std::vector : begin, end and insert - Using Objects instead of ints
Hi,
I thought I would experimenting with vectors.
I am trying to use CPoint objects instead the examples, which use ints.
So, I am a having a few problems.
Question 1.
How do I get the integer value from _Iter or
How do I use _Iter to get the object?
for (_Iter = pt.begin(); _Iter < pt.end(); _Iter++)
{
CPoint& pt = Pts.at(??);
}
I am not sure about the use of begin and end.
Would 0 and size() be the equivalents?
Would there ever be a difference between them?
Question 2.
How do I go about adding CPoint objects with insert?
Do I have to add the object to the front or back of the list,
then move it to the correct position, then delete it from the list?
P.S. I haven't done any experimenting with get_allocator yet.
rend and rbegin aren't finished.
TIA,
/*** Code start ****/.
std::vector<CPoint> m_Pts;
CPoint Pt(2, 4);
//--------------------------------------------------------------------------------- // Fill Collection //--------------------------------------------------------------------------------- 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); } //--------------------------------------------------------------------------------- // front : Returns a reference to the first element in a vector. // // back : Returns a reference to the last element of the vector. //--------------------------------------------------------------------------------- CPoint& rPt = Pt; 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); //--------------------------------------------------------------------------------- // 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. //--------------------------------------------------------------------------------- int size_type; 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); //--------------------------------------------------------------------------------- // 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"); rPt = m_Pts.at(0); TRACE("Point at 0: Pt.x %d Pt.y %d\n", rPt.x, rPt.y); rPt = m_Pts.at(1); TRACE("Point at 1: Pt.x %d Pt.y %d\n", rPt.x, rPt.y); rPt = m_Pts.at(2); TRACE("Point at 2: Pt.x %d Pt.y %d\n", rPt.x, rPt.y); m_Pts.insert(m_Pts.begin(), m_Pts.begin()+1, m_Pts.begin()+2); TRACE("After\n"); 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); }//Pseudo Code for Inserting an Object// Insert(Object, Loc)// { //Add to end or beginning of list. //Move to where is should be. //Delete it off the end of the list.// } //--------------------------------------------------------------------------------- // 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); //--------------------------------------------------------------------------------- // 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. // //---------------------------------------------------------------------------------/* m_Pts.resize(20); std::vector<CPoint>::const_iterator m_cIter; // *c1_cIter = 200; Error. c1_cIter is constant. m_cIter = m_Pts.begin(); TRACE("Position of Iterator: %d\n", *m_cIter); std::vector<CPoint>::iterator m_Iter; m_Iter = m_Pts.begin(); TRACE("Position of Iterator: %d\n", *m_Iter); m_Iter = m_Pts.end(); TRACE("Position of Iterator: %d\n", *m_Iter); *m_Iter = 10; TRACE("Position of Iterator: %d\n", *m_Iter); 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++) {// int x = m_cIter; CPoint& pt = *m_Iter; TRACE("Pt[%d] Pt.x %d, Pt.y %d\n", pt.x, pt.y); }*/ //--------------------------------------------------------------------------------- // 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(); 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); } //--------------------------------------------------------------------------------- //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"); } return; //--------------------------------------------------------------------------------- // 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