Always use the [ source ] and [ /source ] tags to make sure all of the code shows up:




Are you using namespace std; or using std::list;? If not, do this:




Not that typedef-ing a struct is not necessary in C++, only in C.

Oh, and make sure you #include <list>



[edited by - Kippesoep on March 5, 2003 1:29:29 AM]

quote:Original post by peckerpeck
btw, isn''t it about 6am your time? go to bed!

Nah, that was about 7am. I get up around 5:30am.

quote:
thanks for the tip on source and /source.
are those html tags? and thus your image is
<img src="..."> ?

The source and /source tags (with square brackets) are GameDev specific (see the FAQ). However, HTML is supported, so when you actually need an < or > type &lt; and &gt; respectively. When you need an &, type &amp;

IF you use pointers (new) in your list, don''t forget to clean them up later! You have to iterate through the list in your destructor (or where you destroy the list) and properly delete all pointers. You don''t have to destroy or empty the actualy list, it does that with it''s own destructor.




notice the !=
It''s because list uses nodes all over the memory you can''t actually see if an iterator is < or > than another in a logical way. You CAN write it, but you won''t get the result you''d expect.
And ++iter is "alot" faster than iter++

iterator is kinda like a pointer to the contents in your container. So you have to dereference it (*) to get the contents, which in your case is a pointer.

If you got any more questions I''d be happy to answer them :D

"No lies of sugar can sweeten the sournes of reality"

}+TITANIUM+{ A.K.A. DXnewbie[onMIRC]

In case you didn''t know, the pre-fix and post-fix operators are different because the pre-fix operator (++obj) increments first then returns the object while the post-fix operator (obj++) returns the object first (essentially) and then increments. Well, if you ever get into designing classes that require the overloading of the increment operator, you''ll learn that by its very nature the post-fix operator requires you to create a temporary with the current value, increment your object, and then return the temporary. As you can see, in the context of a for loop, you''d be creating a temporary of a fairly complex object each time through the loop for no particular reason...you get the idea.

______________________________

And the Phoenix shall rise from the ashes...

--Thunder_Hawk -- ¦þ
______________________________

I knew you'd ask those questions :D

some already answered, but I'll gladly answer anyway

quote:
had wondered about the '!='. Are they just integer,
erm DWORD, handles that are stored in the list object somewhere?

they're types. internal classes to be more specific. where they overloaded the * and the -> operators so it works just like a pointer. and overloaded the != and == operators so you can use it in loops etc. (you knew you could overload your own operators for your classes in C++, didn't you?)




that's also why you write list::iterator to access it

quote:
Also, can you point me to or tell me why the ++iterator is
faster

as someone mentioned, postfix (iter++) returns a copy of the iterator and the prefix (++iter) returns a reference.


// NOT ACTUAL STL CODE! This is an illustration. But it works something like this
...
iterator operator ++ () // postfix, returns a "whole" iterator
{
iterator temp = *this;

// increment temp

return temp;
}

iterator& operator ++ ( iterator ) // prefix, returns a reference to itself
{
// increment
return *this;
}
...
[/source]

references are cheap, most times even free (they don't take up space on the stack). So use them! the postfix/prefix thing applies to all types, even int's. Although int's are small try to use ++MyInt instead of MyInt++ whenever you can, so you don't forget that prefix rox0rz ur box0rz

why it's faster: you don't keep creating and destroying objects over and over again (in your loop for example)


[edit] - added some more info *yeey*

[edit] - cleanup

[edit] - more cleanup

[edited by - Seriema on March 6, 2003 3:19:26 AM]