454,376 Members | 1,559 Online Need help? Post your question and get tips & solutions from a community of 454,376 IT Pros & Developers. It's quick & easy.

# STL transform algorithm

 P: n/a Hi, I have the following code which uses STL transform algorithm. It basically takes a list of Rect* object, get all the y attribute and store it in a vector of 'int'. My question is: is there a way to simplify the code? Is there a way for me to get rid of the GetY class, since it essentially just calls 'getY()'. Thank you. class GetY : public std::unary_function { public: int operator()(Rect* r); }; int GetY :: operator()( Rect* r) { return r->getY(); } vector& getY(list _rectList) { vector* _y = new vector(_rectList.size()), transform(_rectList.begin(), _rectList.end(), _y->begin(), GetY()); return *(_y); } Feb 14 '06 #1
5 Replies

 P: n/a Piotr wrote: Hi, I have the following code which uses STL transform algorithm. It basically takes a list of Rect* object, get all the y attribute and store it in a vector of 'int'. My question is: is there a way to simplify the code? Is there a way for me to get rid of the GetY class, since it essentially just calls 'getY()'. Thank you. class GetY : public std::unary_function { public: int operator()(Rect* r); }; int GetY :: operator()( Rect* r) { return r->getY(); } vector& getY(list _rectList) { vector* _y = new vector(_rectList.size()), transform(_rectList.begin(), _rectList.end(), _y->begin(), GetY()); You try mem_fun? transform(begin, end, mem_fun(&Rect::GetY)); return *(_y); } Feb 14 '06 #2

 P: n/a Is there a way to replace these binary function as well? I use them in STL sort algorithm: bool GreaterX::operator()( Rect* bd1, Rect* bd2) { return (bd1->getX() < bd2->getX()); } bool SameX::operator()( Rect* bd1, Rect* bd2) { return (bd1->getX() == bd2->getX()); } Feb 14 '06 #3

 P: n/a Piotr wrote: Is there a way to replace these binary function as well? I use them in STL sort algorithm: bool GreaterX::operator()( Rect* bd1, Rect* bd2) { return (bd1->getX() < bd2->getX()); } bool SameX::operator()( Rect* bd1, Rect* bd2) { return (bd1->getX() == bd2->getX()); } There is all sorts of useful goodies in . Have a look there and/or get Josuttis's book on the std lib. I don't know, I would have to look it up. Feb 14 '06 #4

 P: n/a Piotr wrote: Hi, I have the following code which uses STL transform algorithm. It basically takes a list of Rect* object, get all the y attribute and store it in a vector of 'int'. My question is: is there a way to simplify the code? Is there a way for me to get rid of the GetY class, since it essentially just calls 'getY()'. Thank you. Yes. Take a look at std::mem_fun(), which permits you to eliminate the GetY functor entirely. Here's a reference: http://www.sgi.com/tech/stl/mem_fun_t.html Best regards, Tom Feb 14 '06 #5

 P: n/a In article <11*********************@g43g2000cwa.googlegroups. com>, "Piotr" wrote: Is there a way to replace these binary function as well? I use them in STL sort algorithm: bool GreaterX::operator()( Rect* bd1, Rect* bd2) { return (bd1->getX() < bd2->getX()); } bool SameX::operator()( Rect* bd1, Rect* bd2) { return (bd1->getX() == bd2->getX()); } (I'm assuming getX returns an int.) In both cases, the functions take two Rect*s, call "->getX()" on each and performs a compare on the results returning a bool. The only difference is what is being used to make the comparison. It just so happens that there are two functors in the standard library that already do the two different comparisons (std::less and std::equal_to) so we simply need to create one class that can use either of those functors. It's operator() will look something like this: bool operator()( const Rect* bd1, const Rect* bd2 ) const { return fn( bd1->getX(), bd2->getX() ); } If 'fn' is std::less, then it will return true if bd1's x is less than bd2's x. If 'fn' is std::equal_to, then the two xs must be equal for it to return true. Here is the whole class. template class compare_x_t: public binary_function { Op fn; public: compare_x_t() { } compare_x_t( Op f ): fn( f ) { } bool operator()( const Rect* bd1, const Rect* bd2 ) const { return fn( bd1->getX(), bd2->getX() ); } }; and a helper function for creating the right class object. template compare_x_t compare_x( Op f ) { return compare_x_t( f ); } Now you can: void fn( list& ll, Rect* refRect ) { ll.sort( compare_x( less() ) ); list::iterator it = find_if( ll.begin(), ll.end(), bind2nd( compare_x( equal_to() ), refRect ) ); } The above could be made more generic but don't do it unless you need it. -- Magic depends on tradition and belief. It does not welcome observation, nor does it profit by experiment. On the other hand, science is based on experience; it is open to correction by observation and experiment. Feb 14 '06 #6

### This discussion thread is closed

Replies have been disabled for this discussion. 