code for performance(STL)

1. Erase-remove idiom

 

remove只是把符合要求的项移动到尾部，而不是真正的删掉，而erase把排序后的符合要求的项真正的删掉

 

Example

#include <vector> // the general-purpose vector container
#include <algorithm> // remove and remove_if
 
bool is_odd(int i) // unary predicate returning true if and only if the argument is odd
{
  return i % 2; 
}

bool is_even(int i) // unary predicate returning true if and only if the argument is even
{
  return !is_odd(i);
}
 
int main()
{
  using namespace std;
  int elements[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
  // create a vector that holds the numbers from 0-9.
  vector<int> v(elements, elements + 10);
 
  // use the erase-remove idiom to remove all elements with the value 5
  v.erase(remove(v.begin(), v.end(), 5), v.end());
 
  // use the erase-remove idiom to remove all odd numbers
  v.erase( remove_if(v.begin(), v.end(), is_odd), v.end() );
 
  // use the erase-remove idiom to remove all even numbers
  v.erase( remove_if(v.begin(), v.end(), is_even), v.end() );
}

2. reserve
          STL containers automatically grow to accommodate new insertions.

 

vector<int> v; for(int i = 1; i <= 1000; ++i)      // v automatically grows to make roomv.push_back(i);               // for the insertions This is very convenient but not free.

 

  Multiple realloc-like operations typically take place in the example show above.  Each operation often involvesMemory allocation via the container’s allocator.Copying container elements from the old memory to the new memory.Destructing the elements in the old memory.If the final (or maximum) size of the container is known in advance, the reallocations can be avoided by calling reserve. 

 

vector<int> v;

v.reserve(1000);

 for(int i = 1; i <= 1000; ++i)      // v’s capacity never changes;

v.push_back(i);                    

 // It’s big enough.   

 

3. range

       

Repeated single element calls on Sequence Containers can be expensive.  Examples of sequence containers are vector, string, list, deque.  It is preferable to use range member functions to single-element versions for sequence containers.

Consider the following code snippet:

// Copy elements of src to the beginning of dest

//

void Preappend(const vector<int>& src, vector<int>& dest)

{

      vector<int>::iterator destLoc(dest.begin());

 

      for(vector<int>::const_iterator it = src.begin(); it != src.end(); ++it) {

            destLoc = dest.insert(destLoc, *it);

      }

}

Each call to insert might:

Exhaust dest’s capacity, in which case it must:
Allocate more memory
Copy existing data to new memory
Destroy data in old memory
Deallocate old memory
Even when reallocation is unnecessary, each element beyond the insertion point must be moved up one position to make room for the new element in each iteration of the for loop.
 
In general this linear looking algorithm is really quadratic.

A range version is a follows:

// Copy elements of src to the beginning of dest

//

void Preappend(const vector<int>& src, vector<int>& dest)

{

      dest.insert(dest.begin(), src.begin(), src.end());

}

 

 

 4. resize

 The clear() method on STL containers actually de-allocates the buffer.  So in cases where the containers need to cleaned of existing elements without de-allocating the buffer it is preferable to use resize. 

 

depNodes.resize(0);

 

p->GetDeps(&depNodes) ;