Re: std::vector : begin, end and insert - Using Objects instead of ints
This is a multi-part message in MIME format.
------=_NextPart_000_006C_01C77C04.53A3DDF0
Content-Type: text/plain;
charset="iso-8859-1"
Content-Transfer-Encoding: quoted-printable
Hi Nobody,
I have this problem all the time. Are you using Outlook Express or =
Windows Mail (as it's not called)? I always have to go back and =
reindent my code when I post snippets. It's annoying, but not too big =
of a deal since the tab key works nicely. One weird thing is I often =
have to switch from Plain Text, to Rich Text, then back to Plain Text to =
get it to display the pasted text correctly (sans indentation that is).
Tom
"Nobody" <Nobody@yahoo.com> wrote in message =
news:usgWTSCfHHA.5052@TK2MSFTNGP06.phx.gbl...
Hi,
I don't know why I can't paste it in plain text.
I have to format it for HTML in order for it to display correctly.
I will have to post elsewhere to figure out why plain text is not =
working correctly.
Again. Sorry for the inconvenience.
Since you seem interested in Vectors as well, I have added the whole =
experiment.
It should compile without errors.
I commented out where I am having trouble.
I am having a problem with insert too.
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 =
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.
//
=
//-----------------------------------------------------------------------=
----------
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++)
{
// CPoint& pt = m_Pts.at(1);
// TRACE("Pt[%d] Pt.x %d, Pt.y %d\n", pt.x, pt.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);
=
//-----------------------------------------------------------------------=
----------
// 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");
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);
}
=
//-----------------------------------------------------------------------=
----------
// 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 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);
//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 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");
}
return;
=
//-----------------------------------------------------------------------=
----------
// 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
------=_NextPart_000_006C_01C77C04.53A3DDF0
Content-Type: text/html;
charset="iso-8859-1"
Content-Transfer-Encoding: quoted-printable
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML><HEAD>
<META http-equiv=Content-Type content="text/html; =
charset=iso-8859-1">
<META content="MSHTML 6.00.6000.16397" name=GENERATOR>
<STYLE></STYLE>
</HEAD>
<BODY bgColor=#ffffff>
<DIV><FONT face=Arial size=2>Hi Nobody,</FONT></DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial size=2>I have this problem all the time. =
Are you
using Outlook Express or Windows Mail (as it's not called)? I =
always have
to go back and reindent my code when I post snippets. It's =
annoying, but
not too big of a deal since the tab key works nicely. One weird =
thing is I
often have to switch from Plain Text, to Rich Text, then back to Plain =
Text to
get it to display the pasted text correctly (sans indentation that
is).</FONT></DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial size=2>Tom</FONT></DIV>
<BLOCKQUOTE dir=ltr
style="PADDING-RIGHT: 0px; PADDING-LEFT: 5px; MARGIN-LEFT: 5px; =
BORDER-LEFT: #000000 2px solid; MARGIN-RIGHT: 0px">
<DIV>"Nobody" <<A =
href="mailto:Nobody@yahoo.com">Nobody@yahoo.com</A>>
wrote in message <A
=
href="news:usgWTSCfHHA.5052@TK2MSFTNGP06.phx.gbl">news:usgWTSCfHHA.5052=
@TK2MSFTNGP06.phx.gbl</A>...</DIV>
<DIV><FONT face=Arial size=2>Hi,</FONT></DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial size=2>I don't know why I can't paste it in =
plain
text.</FONT></DIV>
<DIV><FONT face=Arial size=2>I have to format it for =
HTML in order
for it to display correctly.</FONT></DIV>
<DIV><FONT face=Arial size=2>I will have to post elsewhere to =
figure out why
plain text is not working correctly.</FONT></DIV>
<DIV><FONT face=Arial size=2>Again. Sorry for the =
inconvenience.</FONT></DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial size=2>Since you seem interested =
in Vectors as
well, I have added the whole experiment.</FONT></DIV>
<DIV><FONT face=Arial size=2>It should compile without =
errors.</FONT></DIV>
<DIV><FONT face=Arial size=2>I commented out where I am having
trouble.</FONT></DIV>
<DIV><FONT face=Arial size=2>I am having a problem with insert
too.</FONT></DIV>
<DIV> </DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial size=2> std::vector<CPoint>
m_Pts;</FONT></DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial size=2> CPoint Pt(2, 4);</FONT></DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial
=
size=2> //--------------------------------------------------------=
-------------------------<BR> //
Fill
=
Collection<BR> //---------------------------------------------------=
------------------------------<BR> for
(UINT i = 1; i < 11; i++)<BR> {<BR> CPoint
Pt;<BR> Pt.x = i;<BR> Pt.y =
i;<BR> m_Pts.push_back(Pt);<BR> }</FONT></DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial
=
size=2> //--------------------------------------------------------=
-------------------------<BR> //
at : Returns a reference to the element at a specified location in the =
=
vector.<BR> //------------------------------------------------------=
---------------------------<BR> for
(UINT i = 0; i < 10; i++)<BR> {<BR> CPoint& =
rPt =
m_Pts.at(i);<BR> TRACE("Pt[%d] Pt.x %d, Pt.y %d\n", i, =
rPt.x,
rPt.y);<BR> }</FONT></DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial
=
size=2> //--------------------------------------------------------=
-------------------------<BR> //
begin : A random-access iterator addressing the first element in the =
vector or
<BR> // to the =
location
succeeding an empty vector. You should always compare
<BR> // the value =
returned with vector::end to ensure it is =
valid.<BR> //<BR> // end :
A random-access iterator to the end of the vector object. You should
<BR> // compare the value =
returned to
vector::begin to ensure it is
=
valid.<BR> //<BR> //-------------------------------------------=
--------------------------------------<BR> m_Pts.resize(20);<BR>&nbs=
p;std::vector<CPoint>::const_iterator
m_cIter;<BR> // *c1_cIter = 200; Error. c1_cIter is
constant.<BR> m_cIter = m_Pts.begin();<BR> TRACE("Position =
of
Iterator: %d\n", *m_cIter);</FONT></DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial =
size=2> std::vector<CPoint>::iterator
m_Iter;<BR> m_Iter = m_Pts.begin();<BR> TRACE("Position of =
Iterator:
%d\n", *m_Iter);<BR> m_Iter = =
m_Pts.end();<BR> TRACE("Position of
Iterator: %d\n", *m_Iter);<BR> *m_Iter = =
10;<BR> TRACE("Position of
Iterator: %d\n", *m_Iter);</FONT></DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial size=2> for (UINT i = 0; i < =
m_Pts.size();
i++)<BR> {<BR> CPoint& rPt =
m_Pts.at(i);<BR> TRACE("Pt[%d] Pt.x %d, Pt.y %d\n", i, =
rPt.x,
rPt.y);<BR> }</FONT></DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial size=2> for(m_Iter = m_Pts.begin(); =
m_Iter <
m_Pts.end(); m_Iter++)<BR> {<BR>// CPoint& pt =
m_Pts.at(1);<BR>// TRACE("Pt[%d] Pt.x %d, Pt.y %d\n", pt.x, =
pt.y);<BR> }</FONT></DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial
=
size=2> //--------------------------------------------------------=
-------------------------<BR> //
front : Returns a reference to the first element in a =
vector.<BR> //
<BR> // back : Returns a reference to the last element of the
=
vector.<BR> //------------------------------------------------------=
---------------------------<BR> CPoint&
rPt = Pt;<BR> rPt = m_Pts.front();<BR> TRACE("front: =
Pt.x %d, Pt.y
%d\n", rPt.x, rPt.y);<BR> rPt = =
m_Pts.back();<BR> TRACE("back: Pt.x
%d, Pt.y %d\n", rPt.x, rPt.y);</FONT></DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial size=2> rPt = =
m_Pts.front();<BR> TRACE("front:
Pt.x %d, Pt.y %d\n", rPt.x, rPt.y);<BR> rPt =
m_Pts.back();<BR> TRACE("back: Pt.x %d, Pt.y %d\n", rPt.x,
rPt.y);</FONT></DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial
=
size=2> //--------------------------------------------------------=
-------------------------<BR> //
insert : Inserts an element or a number of elements or a range of =
elements
into =
<BR> // the
vector at a specified position.<BR> //<BR> // Optional :
m_Pts.insert(m_Pts.begin(), 1,
=
2);<BR> // &nbs=
p;
m_Pts.insert(m_Pts.begin(),
=
2);<BR> //<BR> //----------------------------------------------=
-----------------------------------<BR> TRACE("insert\n");<BR> =
TRACE("Before\n");<BR> rPt
= m_Pts.at(0);<BR> TRACE("Point at 0: Pt.x %d Pt.y %d\n", =
rPt.x,
rPt.y);<BR> rPt = m_Pts.at(1);<BR> TRACE("Point at 1: Pt.x =
%d Pt.y
%d\n", rPt.x, rPt.y);<BR> rPt = =
m_Pts.at(2);<BR> TRACE("Point at 2:
Pt.x %d Pt.y %d\n", rPt.x, rPt.y);</FONT></DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial size=2> m_Pts.insert(m_Pts.begin(),
m_Pts.begin()+1, m_Pts.begin()+2);</FONT></DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial size=2> TRACE("After\n");<BR> for =
(UINT i = 0;
i < m_Pts.size(); i++)<BR> {<BR> CPoint& rPt =
=
m_Pts.at(i);<BR> TRACE("Pt[%d] Pt.x %d, Pt.y %d\n", i, =
rPt.x,
rPt.y);<BR> }</FONT></DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial
=
size=2> //--------------------------------------------------------=
-------------------------<BR> //
size : Returns the number of elements in the =
vector.<BR> //<BR> //
max_size: The maximum size of the vector.<BR> //<BR> // =
capacity
: the number of elements that the vector could contain without
=
<BR> // &=
nbsp;
allocating more
=
storage.<BR> //-----------------------------------------------------=
----------------------------<BR> int
size_type;<BR> size_type = m_Pts.size();<BR> TRACE("size : =
%d\n",
size_type);</FONT></DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial size=2> size_type =
m_Pts.capacity();<BR> TRACE("capacity : %d\n", =
size_type);</FONT></DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial size=2> size_type =
m_Pts.max_size(); <BR> TRACE("max_size : %d\n",
size_type);</FONT></DIV>
<DIV> </DIV>
<DIV><FONT face=Arial
=
size=2> //--------------------------------------------------------=
-------------------------<BR> //
resize : Specifies a new size for a vector.<BR> //<BR> // If =
the
container's size is less than the requested size, _Newsize, elements =
are
<BR> // added to the vector until it reaches the requested size. =
If the
container's size <BR> // is larger than the requested size, the =
elements
closest to the end of the <BR> // container are deleted until the =
container reaches the size _Newsize.
=
<BR> //-------------------------------------------------------------=
--------------------<BR> TRACE("resize
- grow\n");<BR> m_Pts.resize(20);<BR> size_type =
m_Pts.size();<BR> TRACE("size : %d\n", size_type);<BR> rPt =
=
m_Pts.front();<BR> TRACE("front: Pt.x %d, Pt.y %d\n", rPt.x,
rPt.y);<BR> rPt = m_Pts.back();<BR> TRACE("back: Pt.x %d, =
Pt.y
%d\n", rPt.x, rPt.y);</FONT></DIV>
<DIV> </DIV>
<DIV><FONT face=Arial size=2> TRACE("resize -
shrink\n");<BR> m_Pts.resize(5);<BR> size_type =
m_Pts.size();<BR> TRACE("size : %d\n", size_type);<BR> rPt =
=
m_Pts.front();<BR> TRACE("front: Pt.x %d, Pt.y %d\n", rPt.x,
rPt.y);<BR> rPt = m_Pts.back();<BR> TRACE("back: Pt.x %d, =
Pt.y
%d\n", rPt.x, rPt.y);</FONT></DIV>
<DIV> </DIV>
<DIV><FONT face=Arial
=
size=2> //--------------------------------------------------------=
-------------------------<BR> //
reserve : Reserves a minimum length of storage for a vector object, =
allocating
=
<BR> // =
space
if
=
necessary.<BR> // &nb=
sp;
*Changes the
=
capacity.<BR> //----------------------------------------------------=
-----------------------------<BR> TRACE("reserve\n");<BR> TRACE=
("Before\n");<BR> size_type
= m_Pts.size();<BR> TRACE("size : %d\n", =
size_type);<BR> size_type =
m_Pts.capacity();<BR> TRACE("capacity : %d\n",
size_type);<BR> size_type =
m_Pts.max_size(); <BR> TRACE("max_size : %d\n",
size_type);</FONT></DIV>
<DIV> </DIV>
<DIV><FONT face=Arial =
size=2> m_Pts.reserve(100);</FONT></DIV>
<DIV> </DIV>
<DIV><FONT face=Arial =
size=2> TRACE("After\n");<BR> size_type =
m_Pts.size();<BR> TRACE("size : %d\n", =
size_type);<BR> size_type =
m_Pts.capacity();<BR> TRACE("capacity : %d\n",
size_type);<BR> size_type =
m_Pts.max_size(); <BR> TRACE("max_size : %d\n",
size_type);</FONT></DIV>
<DIV> </DIV>
<DIV><FONT face=Arial size=2> rPt = =
m_Pts.front();<BR> TRACE("front:
Pt.x %d, Pt.y %d\n", rPt.x, rPt.y);<BR> rPt =
m_Pts.back();<BR> TRACE("back: Pt.x %d, Pt.y %d\n", rPt.x,
rPt.y);</FONT></DIV>
<DIV> </DIV>
<DIV><FONT face=Arial
=
size=2> //--------------------------------------------------------=
-------------------------<BR> //
pop_back : Deletes the element at the end of the
=
vector.<BR> //------------------------------------------------------=
---------------------------<BR> TRACE("pop_back\n");<BR> TRACE(=
"Before\n");<BR> rPt
= m_Pts.back();<BR> TRACE("back: Pt.x %d, Pt.y %d\n", rPt.x,
rPt.y);<BR> size_type = m_Pts.size();<BR> TRACE("size : =
%d\n",
size_type);</FONT></DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial size=2> m_Pts.pop_back();</FONT></DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial size=2> TRACE("After\n");<BR> rPt =
=
m_Pts.back();<BR> TRACE("back: Pt.x %d, Pt.y %d\n", rPt.x,
rPt.y);<BR> size_type = m_Pts.size();<BR> TRACE("size : =
%d\n",
size_type);</FONT></DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial
=
size=2> //--------------------------------------------------------=
-------------------------<BR> //
push_back : Adds elements to the
=
end<BR> //----------------------------------------------------------=
-----------------------<BR> TRACE("push_back\n");<BR> TRACE("Be=
fore\n");<BR> rPt
= m_Pts.back();<BR> TRACE("back: Pt.x %d, Pt.y %d\n", rPt.x,
rPt.y);<BR> size_type = m_Pts.size();<BR> TRACE("size : =
%d\n",
size_type);</FONT></DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial
size=2> m_Pts.push_back(CPoint(88,99));</FONT></DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV>
<DIV><FONT face=Arial size=2> TRACE("After\n");<BR> rPt =
=
m_Pts.back();<BR> TRACE("back: Pt.x %d, Pt.y %d\n", rPt.x,
rPt.y);<BR> size_type = m_Pts.size();<BR> TRACE("size : =
%d\n",
size_type);</FONT></DIV>
<DIV><FONT face=Arial size=2></FONT> </DIV><FONT face=Arial =
size=2>
<DIV><BR>//Pseudo Code for Inserting an =
Object<BR>// Insert(Object,
Loc)<BR>// {<BR> //Add to end or beginning of
list.<BR> //Move to where is should =
be.<BR> //Delete it
off the end of the list.<BR>// }</DIV>
<DIV> </DIV>
=
<DIV> //------------------------------------------------------------=
---------------------<BR> //
erase : Removes an element or a range of elements in a vector from =
specified
<BR> //
=
positions.<BR> //---------------------------------------------------=
------------------------------<BR> TRACE("erase\n");<BR> m_Pts.=
erase(m_Pts.begin(),
m_Pts.begin()+1);<BR> for (UINT i = 0; i < m_Pts.size();
i++)<BR> {<BR> CPoint& rPt =
m_Pts.at(i);<BR> TRACE("Pt[%d] Pt.x %d, Pt.y %d\n", i, =
rPt.x,
rPt.y);<BR> }<BR> size_type = =
m_Pts.size();<BR> TRACE("size :
%d\n", size_type);</DIV>
<DIV> </DIV>
=
<DIV> //------------------------------------------------------------=
---------------------<BR> //
assign: Erases a vector and copies the specified elements to the empty =
vector.<BR> //<BR> // m_Pts2.assign(m_Pts.begin(),
m_Pts.end()); : Copies m_Pts into
m_Pts2<BR> //<BR> // m_Pts3.assign(5, CPoint(66,77)); : =
Copies
CPoint 5 times into first 5
=
elements<BR> //-----------------------------------------------------=
----------------------------<BR> std::vector<CPoint>
m_Pts2;<BR> std::vector<CPoint> =
m_Pts3;<BR> TRACE("assign -
part 1.\n");<BR> m_Pts2.assign(m_Pts.begin(),
m_Pts.end());<BR> for(UINT nItem = 0; nItem < m_Pts2.size(); =
nItem++)<BR> {<BR> CPoint& pt =
m_Pts2.at(nItem);<BR> TRACE("Pt[%d] Pt.x %d, Pt.y %d\n", =
nItem,
pt.x, pt.y);<BR> }</DIV>
<DIV> </DIV>
<DIV> TRACE("assign - part 2.\n");<BR> m_Pts3.assign(5,
CPoint(66,77));<BR> for(UINT nItem = 0; nItem < =
m_Pts3.size();
nItem++)<BR> {<BR> CPoint& pt =
m_Pts3.at(nItem);<BR> TRACE("Pt[%d] Pt.x %d, Pt.y %d\n", =
nItem,
pt.x, pt.y);<BR> }</DIV>
<DIV> </DIV>
=
<DIV> //------------------------------------------------------------=
---------------------<BR> //
swap : Exchanges the elements of two
=
vectors.<BR> //-----------------------------------------------------=
----------------------------<BR> TRACE("swap\n");<BR> m_Pts2.sw=
ap(m_Pts3);<BR> for(UINT
nItem = 0; nItem < m_Pts2.size();
nItem++)<BR> {<BR> CPoint& pt =
m_Pts2.at(nItem);<BR> TRACE("Pt[%d] Pt.x %d, Pt.y %d\n", =
nItem,
pt.x,
=
pt.y);<BR> }<BR> //--------------------------------------------=
-------------------------------------<BR> //rbegin
: Returns an iterator to the first element in a reversed
=
vector.<BR> //------------------------------------------------------=
---------------------------<BR>/*<BR> std::vector<CPoint>::rev=
erse_iterator
m_rIter;<BR> for(m_rIter = m_Pts.rbegin(); m_rIter < =
m_Pts2.size();
m_rIter++)<BR> {<BR> CPoint& pt =
m_Pts2.at(nItem);<BR> TRACE("Pt[%d] Pt.x %d, Pt.y %d\n", =
nItem,
pt.x,
=
pt.y);<BR> }<BR>*/<BR> //--------------------------------------=
-------------------------------------------<BR> //rend
: A reverse random-access iterator that addresses the location =
succeeding
<BR> // the last element in a =
reversed vector (the location that had preceded the
<BR> // first element in the
unreversed
=
vector).<BR> //-----------------------------------------------------=
----------------------------<BR>/*<BR> for(m_rIter
= m_Pts.rbegin(); rIter < m_Pts2.size();
rIter++)<BR> {<BR> CPoint& pt =
m_Pts2.at(nItem);<BR> TRACE("Pt[%d] Pt.x %d, Pt.y %d\n", =
nItem,
pt.x,
=
pt.y);<BR> }<BR>*/<BR> //--------------------------------------=
-------------------------------------------<BR> //
clear : Erases the elements of the vector.<BR> //<BR> // =
empty :
Tests if the vector is
=
empty.<BR> //-------------------------------------------------------=
--------------------------<BR> if( m_Pts.empty())<BR> {<BR=
TRACE("Vector
is Empty\n");<BR> }else{<BR> TRACE("Vector is Not
Empty\n");<BR> }</DIV>
<DIV> </DIV>
<DIV> m_Pts.clear();</DIV>
<DIV> </DIV>
=
<DIV> if( m_Pts.empty())<BR> {<BR> TRACE("Vecto=
r is
Empty\n");<BR> }else{<BR> TRACE("Vector is Not
Empty\n");<BR> } <BR> return;</DIV>
<DIV> </DIV>
=
<DIV><BR> //--------------------------------------------------------=
-------------------------<BR> //
get_allocator : Returns a copy of the allocator object used to =
construct the
=
<BR> // &=
nbsp;
=
vector.<BR> //------------------------------------------------------=
---------------------------<BR>// m_Pts.get_allocator();<BR> &n=
bsp;
// The following lines declare objects that use the default
allocator.<BR>// vector<int> v1;<BR>// =
vector<int,
allocator<int> > v2 = vector<int, allocator<int>
>(allocator<int>( )) ;</DIV>
<DIV> </DIV>
<DIV> // v3 will use the same allocator class =
as
v1<BR>// vector <int> v3( v1.get_allocator( ) );</DIV>
<DIV> </DIV>
<DIV>// vector<int>::allocator_type xvec = =
v3.get_allocator(
);<BR> // You can now call functions on the =
allocator class
used by vec</DIV>
<DIV> </DIV>
<DIV></FONT> </DIV>
<DIV><FONT face=Arial =
size=2></FONT> </DIV></BLOCKQUOTE></BODY></HTML>
------=_NextPart_000_006C_01C77C04.53A3DDF0--