Effective STL & C++ STL tutorial summaries

Item 6: Be alert for C++’s most vexing parse.

read all word

std::vector<std::string> vs((std::istream_iterator<std::string>("somefilename")),

       std::istream_iterator<std::string>());

 

read all line

std::vector<std::string> vs;

std::string somestring;

std::ifstream somefile("somefilename");

while (std::getline(somefile, somestring)) vs.push_back(somestring);

 

Item 9: Choose carefully among erasing options

/

remove single bad value

/

vector: c.erase(remove(c.begin(), c.end(), badvalue), c.end())

list: c.remove(badvalue)

map: c.erase(badkey)

 

/

remove bad value by condition: bool IsBad(int x)

/

vector: c.erase(remove(c.begin(), c.end(), IsBad), c.end())

 

list: c.remove_if(IsBad)

 

map:

map good;

remove_copy_if(org.begin() org.end(), inserter(good, good.end()), IsBadKey);

org.swap(good)

 

 

/

loop, proccess and remove

/

vector & list:

 

for(.. it = c.begin(); it != c.end();  /*empty*/)

{

       if(IsBad(*it))

              it = c.erase(it)

       else

              it++;

}

 

map

for(.. it = m.begin(); it != m.end(); /*empty*/)

{

       if(IsBadKey(it->first))

       {

              it_del = it++;

              m.erase(it_del);

       }

       else

              it++;

}

 

 

C++ Standard Library: A Tutorial and Reference

 

mem_fun, mem_fun_ref, ptr_fun

class Number

{

private:

       int _val;

public:

       Number(int n): _val(n) {}

       int Value() const { return _val; }

       void mem_print() const

       {

              cout << _val << endl;

       }

 

       bool IsGreaterThan6()

       {

              return _val > 6;

       }

};

 

void global_print(const Number &x)

{

       cout << x.Value() << endl;

}

 

.......

.......

.......

vector<Number> vn;

vector<Number*> vpn;

for(int i = 0; i < 10; i++)

{

       vn.push_back(Number(i));

       vpn.push_back(new Number(i));

}

 

cout << "ordinary functions" << endl;

for_each(vn.begin(), vn.end(), ptr_fun(global_print));

//the same as : for_each(vn.begin(), vn.end(), global_print);

 

cout << "mem_fun_ref" << endl;

for_each(vn.begin(), vn.end(), mem_fun_ref(&Number::mem_print));

cout << "mem_fun" << endl;

for_each(vpn.begin(), vpn.end(), mem_fun(&Number::mem_print));

 

 

for(int i = 0; i < 10; i++)

       delete vpn[i];

 

 

reverse iterator

// v1 = 0, 1,2, ... 9

 

vector<int>::iterator pos5 = find(v1.begin(), v1.end(), 5);

cout << *pos5 << endl; // 5

 

// convert normal iterator to reverse iterator, but value change!!!!!

vector<int>::reverse_iterator rp(pos5);

cout << *rp << endl;  // 4 !!!!!!!!!

 

// convert reverse_iterator to normal iterator

assert(pos5 == rp.base());

 

// convert begin() to reverse_iterator is causing ERROR

//vector<int>::reverse_iterator rpos(v1.begin()) // RUNTIME ERROR!!!!

 

vector<int>::reverse_iterator r2(v1.begin()+2);

vector<int>::reverse_iterator r6(v1.begin()+6);

 

// correct !!

copy(r6, r2, ostream_iterator<int>(cout, ",")); cout << endl;

 

// ERROR!!1

//copy(r2, r6, ostream_iterator<int>(cout, ",")); cout << endl;

 

// construct a vector from stringstream

stringstream ss("0 1 2 3 4 5");

vector<int> v1;

copy((istream_iterator<int>(ss)),istream_iterator<int>(), back_inserter(v1));

 

bool IsEven_Function(int n)

{

       return n % 2 == 0;

}

 

//function pointer V.S. function object

l  Functor can hold state, while free function can’t

 

struct IsEven_Functor : public unary_function<int, bool>

{

       bool operator()(int value) const

       {

              return value % 2 == 0;

       }

};

 

// function pointer

remove_copy_if(v1.begin(), v1.end(), back_inserter(res), not1(ptr_fun(IsEven_Function)));

 

// functor, IsEven_Functor need to derived from unary_function to support not1(), and operator() should be const

remove_copy_if(v1.begin(), v1.end(), back_inserter(res), not1(IsEven_Functor()));

 

 

// multimap as dictionary

multimap<string, string> dict;

dict.insert(make_pair("Fruit", "Apple"));

dict.insert(make_pair("Fruit", "Pear"));

dict.insert(make_pair("Fruit", "Orange"));

dict.insert(make_pair("Animal", "Cat"));

dict.insert(make_pair("Animal", "Dog"));

dict.insert(make_pair("Animal", "Pig"));

dict.insert(make_pair("Animal", "Cow"));

 

string category("Fruit");

cout << category << endl;

for(multimap<string, string>::iterator it = dict.lower_bound(category);

       it != dict.upper_bound(category); ++it)

{

       cout << "/t" << it->second << endl;

}

 

// - pass function object by reference

//insert values from 1 to 4

//so that it will continue with 5

generate_n<back_insert_iterator<list<int> >,

       int, IntSequence&>(back_inserter(coll),            //start

       4,      //number of elements

       seq);   //generates values

 

 

query the state of your function object by checking the return value of for_each().

 

predefined function objects

 

Expression	Effect
negate< type >()	- param
plus< type >()	param1 + param2
minus< type >()	param 1 - param2
multiplies< type >() [4]	param1 * param2
divides< type >()	param1 / param2
modulus < type >()	param1 % param2
equal_to< type >()	param1 == param2
not_equal_to< type >()	param1 ! = param2
less< type >()	param1 < param2
greater< type >()	param1 > param2
less_equal< type >()	param1 <= param2
greater_equal< type >()	param1 >= param2
logical_not< type >()	! param
logical_and< type >()	param1 && param2
logical_or< type > ()	param1 | | param2

 

predefined function adapters

Expression	Effect
bind1st (op,value)	op(value,param)
bind2nd (op, value)	op(param,value)
not 1 (op)	!op(param)
not2 (op)	!op(param1 ,param2)

 

predefined function adapters for member functions

Expression	Effect
mem_fun_ref (op)	Calls op() as a constant member function for an object
mem_fun (op)	Calls op() as a constant member function for an object

 

Function Adapters for Oridnary Functions

Expression	Effect
ptr_fun (op)	*op(param)
	*op(param1 ,param2)