A Review of Iterator and Several std methods

buffList.remove_if(std::mem_fun(&Buff::hasTimedOut));

for (std::list<item*>::iterator i=items.begin();i!=items.end();i++)
{
    bool isActive = (*i)->update();
    //if (!isActive) 
    //  items.remove(*i); 
    //else
       other_code_involving(*i);
}
items.remove_if(CheckItemNotActive); But get "List iterator not incrementable" error while doing i++. Then I recalled that I did the same thing several months ago, but can't remember how to fixed it.That is why I start to write blog. We Chinese says that "The palest ink is better than the best memory".

std::list<int> intList;
for (int i = 0; i < 10; ++i)
{
	intList.push_back(i);
}

for (std::list<int>::iterator i = intList.begin(); i != intList.end(); ++i)
{
	if (*itor % 2 == 1)
	{
		intList.erase(itor);
	}
} We can avoid that error by changing it to:

std::list<int> intList;
for (int i = 0; i < 10; ++i)
{
	intList.push_back(i);
}

for (std::list<int>::iterator i = intList.begin(); i != intList.end(); ++i)
{
	if (*itor % 2 == 1)
	{
		intList.erase(itor++);
		// or itor = intList.erase(itor);
	}
	else
		++itor;
} That due to the difference between pre-increment and post-increment operators.

intList.erase(itor++);
intList.erase(++itor); For ++itor(fake code)

return itor += 1；

copyItor = *this;
*this += 1;
return copyItor; **（So that, most people argues that using ++i has a performance gain. I guess it is real at least in c++.）**

std::vector<int> intVector;
for (int i = 0; i < 10; ++i)
{
	intVector.push_back(i);
}

std::Vector<int>::iterator itor = intVector.begin();
while (itor != intVector.end())
{
	if (*itor % 2 == 1)
	{
		//itor = intVector.erase(itor);
		intVector.erase(itor++);
	}
	else
		++itor;
} About to the reason of this issue, Eric Seppanen says:

	if (*itor % 2 == 1)
	{
		//itor = intVector.erase(itor);
		intVector.erase(itor++);
	}

// Note: Using the pre-increment operator is preferred     for iterators because
//       there can be a performance gain.
//
// Note: As long as you are iterating from beginning to     end, without inserting
//       along the way you can safely save end once;     otherwise get it at the
//       top of each loop.

std::list< item * >::iterator iter = items.begin();
std::list< item * >::iterator end  = items.end();

while (iter != items.end())
{
    item * pItem = *iter;

    if (pItem->update() == true)
    {
        other_code_involving(pItem);
        ++iter;
    }
    else
    {
        // BTW, who is deleting pItem, a.k.a. (*iter)?
        iter = items.erase(iter);
    }
} Then, he gives a specific answer for skill update system

// This implementation of update executes     other_code_involving(Item *) if
// this instance needs updating.
//
// This method returns true if this still needs future     updates.
//
bool Item::update(void)
{
    if (m_needsUpdates == true)
    {
        m_needsUpdates = other_code_involving(this);
    }

    return (m_needsUpdates);
}

// This call does everything the previous loop did!!!     (Including the fact
// that it isn't deleting the items that are erased!)
items.remove_if(std::not1(std::mem_fun(&Item::update))); This is a gem(for me at least):

items.remove_if(std::not1(std::mem_fun(&Item::update)));

int op_increase (int i) { return ++i; }

// example of std::transform
void std_transform()
{
	std::vector<int> foo;
	std::vector<int> bar;

	// set some values:
	for (int i=1; i<6; i++)
		foo.push_back (i*10);                         // foo: 10 20 30 40 50

	bar.resize(foo.size());                         // allocate space

	std::transform (foo.begin(), foo.end(), bar.begin(), op_increase);
	// bar: 11 21 31 41 51

	// std::plus adds together its two arguments:
	std::transform (foo.begin(), foo.end(), bar.begin(), foo.begin(), std::plus<int>());
	// foo: 21 41 61 81 101

	std::cout << "foo contains:";
	for (std::vector<int>::iterator it=foo.begin(); it!=foo.end(); ++it)
		std::cout << ' ' << *it;
	std::cout << '\n';
} #### std::not1 Return the oppsite of boolean value. In this case, if the skill has been updated, return true. #### std::remove_if Remove the elements if it match the condition。 *[Aprroach of std::remove_if in C++11][4]：

enter code hertemplate <class ForwardIterator, class UnaryPredicate>
ForwardIterator remove_if (ForwardIterator first, ForwardIterator last, UnaryPredicate pred)
{
  ForwardIterator result = first;
  while (first!=last) {
    if (!pred(*first)) {
      *result = std::move(*first);
      ++result;
    }
    ++first;
  }
  return result;
} #### std::move It gets the rvalue reference of parameter，convert it to xvalue。 According to the [example code][5] 

std::string str = "Hello";
std::vector<std::string> v;
v.push_back(std::move(str)); Move string in str to Vector v, avoding copy process。Now str=""。 Following feature is very intersting:

// string move assignment operator is often implemented as swap,
// in this case, the moved-from object is NOT empty
std::string str2 = "Good-bye";
std::cout << "Before move from str2, str2 = '" << str2 << "'\n";
v[0] = std::move(str2);
std::cout << "After move from str2, str2 = '" << str2 << "'\n";