bind2nd, mem_fun, and references

[Noah Roberts]

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

class X
{
int x;
public:
X(int i) : x(i) {}
bool eq(const X & other) const { return x == other.x; }
};

int main(int argc, char* argv[])
{
std::vector<X> xes(10);

X x(10);

std::vector<X>::iterator it = std::find_if(xes.begin(), xes.end(),
std::bind2nd(std::mem_fun(&X::eq), x));

return 0;
}

Compilation result:


1>c:\program files\microsoft visual studio 8\vc\include\functional(312)
: error C2529: '_Right' : reference to reference is illegal


binder2nd(const _Fn2& _Func,
const typename _Fn2::second_argument_type& _Right)
: op(_Func), value(_Right)
{ // construct from functor and right operand
}

This would follow...

So, what is the correct and portable way to do what I want or is it
just not possible?

 

[Noah Roberts]

So, what is the correct and portable way to do what I want or is it
just not possible?

Nevermind, looking in the standard at the interfaces to these objects
it is clear that it will never work. Need to create new binder2nd that
will.

 

[Alf P. Steinbach]

* Noah Roberts:

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

class X
{
int x;
public:
X(int i) : x(i) {}
bool eq(const X & other) const { return x == other.x; }
};

int main(int argc, char* argv[])
{
std::vector<X> xes(10);

X x(10);

std::vector<X>::iterator it = std::find_if(xes.begin(), xes.end(),
std::bind2nd(std::mem_fun(&X::eq), x));

return 0;
}

Compilation result:


1>c:\program files\microsoft visual studio 8\vc\include\functional(312)
: error C2529: '_Right' : reference to reference is illegal


binder2nd(const _Fn2& _Func,
const typename _Fn2::second_argument_type& _Right)
: op(_Func), value(_Right)
{ // construct from functor and right operand
}

This would follow...

So, what is the correct and portable way to do what I want or is it
just not possible?

One way could be to use to Boost binders (don't know if that works, but
probably, else I would probably have remembered). Another way is to
define a free comparision function. A third, slight adjustment:

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

class X
{
int x;
public:
X(int i) : x(i) {}
bool operator==(const X & other) const { return x == other.x; }
};

int main()
{
std::vector<X> xes(10, X(0));

X x(10);

std::vector<X>::iterator it = std::find_if(
xes.begin(),
xes.end(),
std::bind2nd(std::equal_to<X>(), x)
);
}

 

[Noah Roberts]

* Noah Roberts:

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

class X
{
int x;
public:
X(int i) : x(i) {}
bool eq(const X & other) const { return x == other.x; }
};

int main(int argc, char* argv[])
{
std::vector<X> xes(10);

X x(10);

std::vector<X>::iterator it = std::find_if(xes.begin(), xes.end(),
std::bind2nd(std::mem_fun(&X::eq), x));

return 0;
}

Compilation result:


1>c:\program files\microsoft visual studio 8\vc\include\functional(312)
: error C2529: '_Right' : reference to reference is illegal


binder2nd(const _Fn2& _Func,
const typename _Fn2::second_argument_type& _Right)
: op(_Func), value(_Right)
{ // construct from functor and right operand
}

This would follow...

So, what is the correct and portable way to do what I want or is it
just not possible?

One way could be to use to Boost binders (don't know if that works, but
probably, else I would probably have remembered).

That's out until I can convince boss Boost good.

bool operator==(const X & other) const { return x == other.x; }

That would work except my real-world type is polymorphic.

 

[Noah Roberts]

* Noah Roberts:

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

class X
{
int x;
public:
X(int i) : x(i) {}
bool eq(const X & other) const { return x == other.x; }
};

int main(int argc, char* argv[])
{
std::vector<X> xes(10);

X x(10);

std::vector<X>::iterator it = std::find_if(xes.begin(), xes.end(),
std::bind2nd(std::mem_fun(&X::eq), x));

return 0;
}

Compilation result:


1>c:\program files\microsoft visual studio 8\vc\include\functional(312)
: error C2529: '_Right' : reference to reference is illegal


binder2nd(const _Fn2& _Func,
const typename _Fn2::second_argument_type& _Right)
: op(_Func), value(_Right)
{ // construct from functor and right operand
}

This would follow...

So, what is the correct and portable way to do what I want or is it
just not possible?

One way could be to use to Boost binders (don't know if that works, but
probably, else I would probably have remembered).

That's out until I can convince boss Boost good.

bool operator==(const X & other) const { return x == other.x; }

That would work except my real-world type is polymorphic.

Thanks though.

 

[P.J. Plauger]

* Noah Roberts:

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

class X
{
int x;
public:
X(int i) : x(i) {}
bool eq(const X & other) const { return x == other.x; }
};

int main(int argc, char* argv[])
{
std::vector<X> xes(10);

X x(10);

std::vector<X>::iterator it = std::find_if(xes.begin(), xes.end(),
std::bind2nd(std::mem_fun(&X::eq), x));

return 0;
}

Compilation result:


1>c:\program files\microsoft visual studio 8\vc\include\functional(312)
: error C2529: '_Right' : reference to reference is illegal


binder2nd(const _Fn2& _Func,
const typename _Fn2::second_argument_type& _Right)
: op(_Func), value(_Right)
{ // construct from functor and right operand
}

This would follow...

So, what is the correct and portable way to do what I want or is it
just not possible?

One way could be to use to Boost binders (don't know if that works, but
probably, else I would probably have remembered).

That's out until I can convince boss Boost good.

Perhaps you can convince your boss that TR1 is good, since it will be
part of the next C++ Standard. And you can now get a version that works
out of the box with VC++ from us.

P.J. Plauger
Dinkumware, Ltd.
http://www.dinkumware.com

 

[Rolf Magnus]

* Noah Roberts:

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

class X
{
int x;
public:
X(int i) : x(i) {}
bool eq(const X & other) const { return x == other.x; }
};

int main(int argc, char* argv[])
{
std::vector<X> xes(10);

X x(10);

std::vector<X>::iterator it = std::find_if(xes.begin(), xes.end(),
std::bind2nd(std::mem_fun(&X::eq), x));

return 0;
}

Compilation result:


1>c:\program files\microsoft visual studio 8\vc\include\functional(312)
: error C2529: '_Right' : reference to reference is illegal


binder2nd(const _Fn2& _Func,
const typename _Fn2::second_argument_type& _Right)
: op(_Func), value(_Right)
{ // construct from functor and right operand
}

This would follow...

So, what is the correct and portable way to do what I want or is it
just not possible?

One way could be to use to Boost binders (don't know if that works, but
probably, else I would probably have remembered).

That's out until I can convince boss Boost good.

bool operator==(const X & other) const { return x == other.x; }

That would work except my real-world type is polymorphic.

Well, not in your vector.

 

[Dilip]

* Noah Roberts:
#include <vector>
#include <algorithm>
#include <functional>

class X
{
int x;
public:
X(int i) : x(i) {}
bool eq(const X & other) const { return x == other.x; }
};

int main(int argc, char* argv[])
{
std::vector<X> xes(10);

X x(10);

std::vector<X>::iterator it = std::find_if(xes.begin(), xes.end(),
std::bind2nd(std::mem_fun(&X::eq), x));

return 0;
}

Compilation result:


1>c:\program files\microsoft visual studio 8\vc\include\functional(312)
: error C2529: '_Right' : reference to reference is illegal


binder2nd(const _Fn2& _Func,
const typename _Fn2::second_argument_type& _Right)
: op(_Func), value(_Right)
{ // construct from functor and right operand
}

This would follow...

So, what is the correct and portable way to do what I want or is it
just not possible?

One way could be to use to Boost binders (don't know if that works, but
probably, else I would probably have remembered).

That's out until I can convince boss Boost good.

Perhaps you can convince your boss that TR1 is good, since it will be
part of the next C++ Standard. And you can now get a version that works
out of the box with VC++ from us.

I tried my best doing this and it just doesn't seem to work with
certain types of bosses unless the std library comes bundled with some
high & mighty version of the VC++ compiler (9.0 perhaps?). Does
Dinkumware's TR1 library compile with VC++ 8.0?

 

[P.J. Plauger]

Alf P. Steinbach wrote:
* Noah Roberts:
#include <vector>
#include <algorithm>
#include <functional>

class X
{
int x;
public:
X(int i) : x(i) {}
bool eq(const X & other) const { return x == other.x; }
};

int main(int argc, char* argv[])
{
std::vector<X> xes(10);

X x(10);

std::vector<X>::iterator it = std::find_if(xes.begin(), xes.end(),
std::bind2nd(std::mem_fun(&X::eq), x));

return 0;
}

Compilation result:


1>c:\program files\microsoft visual studio
8\vc\include\functional(312)
: error C2529: '_Right' : reference to reference is illegal


binder2nd(const _Fn2& _Func,
const typename _Fn2::second_argument_type& _Right)
: op(_Func), value(_Right)
{ // construct from functor and right operand
}

This would follow...

So, what is the correct and portable way to do what I want or is it
just not possible?

One way could be to use to Boost binders (don't know if that works,
but
probably, else I would probably have remembered).

That's out until I can convince boss Boost good.

Perhaps you can convince your boss that TR1 is good, since it will be
part of the next C++ Standard. And you can now get a version that works
out of the box with VC++ from us.

I tried my best doing this and it just doesn't seem to work with
certain types of bosses unless the std library comes bundled with some
high & mighty version of the VC++ compiler (9.0 perhaps?).

We're working on that.

Does
Dinkumware's TR1 library compile with VC++ 8.0?

Yes, even the Express Edition.

P.J. Plauger
Dinkumware, Ltd.
http://www.dinkumware.com