Generic indirection adaptor

[Matthias Kaeppler]

Hi,

as a result of my last posting about an adaption class template for
invoking algorithms on a container of iterators or pointers to elements
in another container, I have come up with this code:

#include <vector>
#include <functional>
#include <algorithm>
#include <iostream>

template< typename It, typename Pred >
class indirect_binary : public std::binary_fun ction<It,It,boo l>
{
public:
bool operator() (It lhs, It rhs) const {
return Pred() (*lhs, *rhs);
}
};

int main()
{
typedef std::vector<int > IntVec;
typedef IntVec::iterato r IntVecIt;

std::vector<int > v1;
v1.push_back(5) ;
v1.push_back(2) ;

std::vector<int *> v2;
v2.push_back( &v1[0] );
v2.push_back( &v1[1] );

indirect_binary < int*, std::less<int> > fctor; // note the int*!
std::sort( v2.begin(), v2.end(), fctor );

std::vector<int *>::iterator it = v2.begin();
for( ; it != v2.end(); ++it )
{
std::cout << **it << std::endl;
}
}

Well, it works, output is: 2, 5.
However, you may have noticed that I instantiated the adaptor with int*
instead of IntVecIt. If I do the latter, I get tons of error messages:

deref.cpp: In function `int main()':
deref.cpp:25: error: no matching function for call to `
std::vector<mai n()::IntVecIt, std::allocator< main()::IntVecI t>

::push_back( int*)'
/usr/include/c++/3.3/bits/stl_vector.h:59 6: error: candidates are: void
std::vector<_Tp , _Alloc>::push_b ack(const _Tp&) [with _Tp =
main()::IntVecI t, _Alloc = std::allocator< main()::IntVecI t>]
deref.cpp:26: error: no matching function for call to `
std::vector<mai n()::IntVecIt, std::allocator< main()::IntVecI t>::push_back(

int*)'
/usr/include/c++/3.3/bits/stl_vector.h:59 6: error: candidates are: void
std::vector<_Tp , _Alloc>::push_b ack(const _Tp&) [with _Tp =
main()::IntVecI t, _Alloc = std::allocator< main()::IntVecI t>]
deref.cpp:31: error: conversion from `
__gnu_cxx::__no rmal_iterator<m ain()::IntVecIt *,
std::vector<mai n()::IntVecIt, std::allocator< main()::IntVecI t> > >' to
non-scalar type `__gnu_cxx::__n ormal_iterator< int**, std::vector<int *,
std::allocator< int*> > >' requested
deref.cpp:32: error: no match for 'operator!=' in 'it != std::vector<_Tp ,
_Alloc>::end() [with _Tp = main()::IntVecI t, _Alloc =
std::allocator< main()::IntVecI t>]()'

And another question: Why do I have to take lhs and rhs by value in
operator() ? If I declare it taking const references, it won't compile
either.

I'd be glad for all your input, because I intend to use this template
class pretty often once it is finished, so I want it to be as robust as
possible.

--
Matthias Kaeppler

[Chris Jefferson]

Matthias Kaeppler wrote:

Hi,

as a result of my last posting about an adaption class template for
invoking algorithms on a container of iterators or pointers to elements
in another container, I have come up with this code:

#include <vector>
#include <functional>
#include <algorithm>
#include <iostream>

template< typename It, typename Pred >
class indirect_binary : public std::binary_fun ction<It,It,boo l>
{
public:
bool operator() (It lhs, It rhs) const {
return Pred() (*lhs, *rhs);
}
};

int main()
{
typedef std::vector<int > IntVec;
typedef IntVec::iterato r IntVecIt;

std::vector<int > v1;
v1.push_back(5) ;
v1.push_back(2) ;

std::vector<int *> v2;
v2.push_back( &v1[0] );
v2.push_back( &v1[1] );

indirect_binary < int*, std::less<int> > fctor; // note the int*!
std::sort( v2.begin(), v2.end(), fctor );

std::vector<int *>::iterator it = v2.begin();
for( ; it != v2.end(); ++it )
{
std::cout << **it << std::endl;
}
}

Well, it works, output is: 2, 5.
However, you may have noticed that I instantiated the adaptor with int*
instead of IntVecIt. If I do the latter, I get tons of error messages:
Your comparison operators gets passed already-dereferenced iterators,
not the iterators themselves.
And another question: Why do I have to take lhs and rhs by value in
operator() ? If I declare it taking const references, it won't compile
either.

Strange, I changed your comparison function to:

bool operator() (const It& lhs, const It& rhs) const {

and it worked fine...

Did you mean something else?

Chris

[Matthias Kaeppler]

Chris Jefferson wrote:

Your comparison operators gets passed already-dereferenced iterators,
not the iterators themselves.

What do you mean? Isn't IntVecIt in most cases just a typedef for int*
anyway? At least it is on my implementation. So:

bool operator() (It lhs, It rhs) {
return Pred() (*lhs, *rhs);
}

translates to:

bool operator() (int* lhs, int* rhs) {
return Pred() (*lhs, *rhs);
}

I can't see what's wrong with that.

--
Matthias Kaeppler

[Chris Jefferson]

Matthias Kaeppler wrote:

Chris Jefferson wrote:

Your comparison operators gets passed already-dereferenced iterators,
not the iterators themselves.

What do you mean? Isn't IntVecIt in most cases just a typedef for int*
anyway? At least it is on my implementation. So:

It isn't on my implementation (gcc 3.3.3). Assuming that it is is a big
no-no!

You can however given an iterator into a vector<int> do &*it and get an
int*. I'm not positive this is guaranteed by the standard, I remember
seeing a defect report about it and can't remember if it got accepted.
I've never seen an implementation where it didn't work.

Chris

[Matthias Kaeppler]

Chris Jefferson wrote:

Matthias Kaeppler wrote:

Chris Jefferson wrote:

Your comparison operators gets passed already-dereferenced iterators,
not the iterators themselves.

What do you mean? Isn't IntVecIt in most cases just a typedef for int*
anyway? At least it is on my implementation. So:

It isn't on my implementation (gcc 3.3.3). Assuming that it is is a big
no-no!

You can however given an iterator into a vector<int> do &*it and get an
int*. I'm not positive this is guaranteed by the standard, I remember
seeing a defect report about it and can't remember if it got accepted.
I've never seen an implementation where it didn't work.

Chris

Oh, okay. But is the design of the adaptor okay?

--
Matthias Kaeppler

[Chris Jefferson]

Matthias Kaeppler wrote:

Chris Jefferson wrote:

Matthias Kaeppler wrote:

Chris Jefferson wrote:

Your comparison operators gets passed already-dereferenced
iterators, not the iterators themselves.


What do you mean? Isn't IntVecIt in most cases just a typedef for
int* anyway? At least it is on my implementation. So:

It isn't on my implementation (gcc 3.3.3). Assuming that it is is a
big no-no!

You can however given an iterator into a vector<int> do &*it and get
an int*. I'm not positive this is guaranteed by the standard, I
remember seeing a defect report about it and can't remember if it got
accepted. I've never seen an implementation where it didn't work.

Chris

Oh, okay. But is the design of the adaptor okay?

Yes, it's good :)

Chris

[Matthias Kaeppler]

Oh, one more question:
I want it to work with both functors and functions. However,
"overloadin g" a template doesn't seem to work (I tried to replace the
second template argument with a pointer to function returning bool and
taking two It::value_typeS ).
This however, results in a redefinition error. Okay, so I renamed the
template and tried it this way:

template< typename It >
class indirect_binary _fn: public std::binary_fun ction<It,It,boo l>
{
bool (*pred)(It::val ue_type, It::value_type) ;
public:
indirect_binary _fn( bool (*f)(It::value_ type, It::value_type) )
: pred(f) {}
bool operator() (const It& lhs, const It& rhs) const {
return pred(*lhs, *rhs);
}
};

Error:
deref.cpp:17: error: variable declaration is not allowed here
deref.cpp:19: error: variable declaration is not allowed here
deref.cpp: In constructor `indirect_binar y_fn<It>::indir ect_binary_fn() ':
deref.cpp:19: error: class `indirect_binar y_fn<It>' does not have any
field named `pred'

Why am I not allowed to declare that variable?

--
Matthias Kaeppler

[Kurt Stutsman]

Matthias Kaeppler wrote:

Oh, one more question:
I want it to work with both functors and functions. However,
"overloadin g" a template doesn't seem to work (I tried to replace the
second template argument with a pointer to function returning bool and
taking two It::value_typeS ).
This however, results in a redefinition error. Okay, so I renamed the
template and tried it this way:

template< typename It >
class indirect_binary _fn: public std::binary_fun ction<It,It,boo l>
{
bool (*pred)(It::val ue_type, It::value_type) ; This should be:
// to make life easier, use a typedef
typedef bool (*pred_fn)(type name It::value_type,
typename It::value_type) ;

pred_fn pred;
public:
indirect_binary _fn( bool (*f)(It::value_ type, It::value_type) )
: pred(f) {} Also:
indirect_binary _fn(pred_fn f) : pred(f) {} bool operator() (const It& lhs, const It& rhs) const {
return pred(*lhs, *rhs);
}
};

There is a much better solution though, to allow for both functors and
functions to be called if you use the boost library:

template<class BinaryPredicate >
class indirect_binary _fn : public std::binary_fun ction<typename
boost::binary_t raits<BinaryPre dicate>::first_ argument_type,
typename
boost::binary_t raits<BinaryPre dicate>::second _argument_type,
bool> {
private:
typedef typename boost::binary_t raits<BinaryPre dicate> It;

BinaryPredicate pred;

public:
indirect_binary _fn(BinaryPredi cate f) : pred(f) {}
bool operator() (const It& lhs, const It& rhs)const
{ return pred(*lhs, *rhs); }
};

typename boost::binary_t raits<BinaryPre dicate>::first_ argument_type and
its brother second_argument _type allow you to get the argument types for
either a function pointer or an AdaptableBinary Predicate (which you can
get by deriving your functors from std::binary_fun ction). The
definintion is a little spammy I know, but in the end you have a much
more useful indirection functor here.

[Matthias Kaeppler]

Kurt Stutsman wrote:

Matthias Kaeppler wrote:

Oh, one more question:
I want it to work with both functors and functions. However,
"overloadin g" a template doesn't seem to work (I tried to replace the
second template argument with a pointer to function returning bool and
taking two It::value_typeS ).
This however, results in a redefinition error. Okay, so I renamed the
template and tried it this way:

template< typename It >
class indirect_binary _fn: public std::binary_fun ction<It,It,boo l>
{
bool (*pred)(It::val ue_type, It::value_type) ;

This should be:
// to make life easier, use a typedef
typedef bool (*pred_fn)(type name It::value_type,
typename It::value_type) ;

pred_fn pred;

public:
indirect_binary _fn( bool (*f)(It::value_ type, It::value_type) )
: pred(f) {}

Also:
indirect_binary _fn(pred_fn f) : pred(f) {}

bool operator() (const It& lhs, const It& rhs) const {
return pred(*lhs, *rhs);
}
};

There is a much better solution though, to allow for both functors and
functions to be called if you use the boost library:

template<class BinaryPredicate >
class indirect_binary _fn : public std::binary_fun ction<typename
boost::binary_t raits<BinaryPre dicate>::first_ argument_type,
typename
boost::binary_t raits<BinaryPre dicate>::second _argument_type,
bool> {
private:
typedef typename boost::binary_t raits<BinaryPre dicate> It;

BinaryPredicate pred;

public:
indirect_binary _fn(BinaryPredi cate f) : pred(f) {}
bool operator() (const It& lhs, const It& rhs)const
{ return pred(*lhs, *rhs); }
};

typename boost::binary_t raits<BinaryPre dicate>::first_ argument_type and
its brother second_argument _type allow you to get the argument types for
either a function pointer or an AdaptableBinary Predicate (which you can
get by deriving your functors from std::binary_fun ction). The
definintion is a little spammy I know, but in the end you have a much
more useful indirection functor here.

Nice, thanks for the great advice. I have already lots of boost'ed code
in my program, so I certainly don't mind to add some more.

I'll report back if still something shouldn't work :)

--
Matthias Kaeppler

[Kurt Stutsman]

Matthias Kaeppler wrote:

Kurt Stutsman wrote:

Matthias Kaeppler wrote:

Oh, one more question:
I want it to work with both functors and functions. However,
"overloadin g" a template doesn't seem to work (I tried to replace the
second template argument with a pointer to function returning bool
and taking two It::value_typeS ).
This however, results in a redefinition error. Okay, so I renamed the
template and tried it this way:

template< typename It >
class indirect_binary _fn: public std::binary_fun ction<It,It,boo l>
{
bool (*pred)(It::val ue_type, It::value_type) ;

This should be:
// to make life easier, use a typedef
typedef bool (*pred_fn)(type name It::value_type,
typename It::value_type) ;

pred_fn pred;

public:
indirect_binary _fn( bool (*f)(It::value_ type, It::value_type) )
: pred(f) {}

Also:
indirect_binary _fn(pred_fn f) : pred(f) {}

bool operator() (const It& lhs, const It& rhs) const {
return pred(*lhs, *rhs);
}
};

There is a much better solution though, to allow for both functors and
functions to be called if you use the boost library:

template<class BinaryPredicate >
class indirect_binary _fn : public std::binary_fun ction<typename
boost::binary_t raits<BinaryPre dicate>::first_ argument_type,
typename
boost::binary_t raits<BinaryPre dicate>::second _argument_type,
bool> {
private:
typedef typename boost::binary_t raits<BinaryPre dicate> It; Spotted an error in my code. The above line should be:
typedef typename boost::binary_t raits<BinaryPre dicate>::first_ argument_type It;
BinaryPredicate pred;

public:
indirect_binary _fn(BinaryPredi cate f) : pred(f) {}
bool operator() (const It& lhs, const It& rhs)const
{ return pred(*lhs, *rhs); }
};

typename boost::binary_t raits<BinaryPre dicate>::first_ argument_type
and its brother second_argument _type allow you to get the argument
types for either a function pointer or an AdaptableBinary Predicate
(which you can get by deriving your functors from
std::binary_fun ction). The definintion is a little spammy I know, but
in the end you have a much more useful indirection functor here.

Nice, thanks for the great advice. I have already lots of boost'ed code
in my program, so I certainly don't mind to add some more.

I'll report back if still something shouldn't work :)