bind2nd et références

Version imprimable

Voici un petit code test:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <iostream>
#include <vector>
#include <functional>

using namespace std;

class Foo
{
public:
	Foo(int val) : m_val(val) {}
	bool operator==(const Foo & foo) const { return (foo.m_val == m_val); }

private:
	int m_val;
};

bool same_as(const Foo & val1, const Foo & val2)
{
	return (val1 == val2);
}

int main()
{
    vector<Foo> vf;
    vf.push_back(Foo(1));
    vf.push_back(Foo(2));
    vf.push_back(Foo(3));
    vf.push_back(Foo(4));
    vf.push_back(Foo(5));
    typedef vector<Foo>::const_iterator VI;
    VI p = find_if(vf.begin(), vf.end(), bind2nd(ptr_fun(same_as), Foo(3)));
    cout << ((p != vf.end()) ? "OUI" : "NON") << endl;
    return 0;
}

Si dans ma fonction same_as, j'utilise des références alors, ça ne marche pas, par contre, si j'en ai pas alors ça marche. Comment faire pour que ça marche avec les références?

Chez moi, ton code compile pas..

Par contre, ceci fonctionne:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <iostream>
#include <vector>
#include <functional>
#include <algorithm>
#include <boost/bind.hpp>
 
using namespace std;
 
class Foo
{
public:
	Foo(int val) : m_val(val) {}
	bool operator==(const Foo & foo) const { return (foo.m_val == m_val); }
 
private:
	int m_val;
};
 
bool same_as(const Foo & val1, const Foo & val2)
{
	return (val1 == val2);
}
 
int main()
{
    vector<Foo> vf;
    vf.push_back(Foo(1));
    vf.push_back(Foo(2));
    vf.push_back(Foo(3));
    vf.push_back(Foo(4));
    vf.push_back(Foo(5));
    typedef vector<Foo>::const_iterator VI;
    VI p = find_if(vf.begin(), vf.end(), boost::bind( same_as, _1, Foo(3) ));
    cout << ((p != vf.end()) ? "OUI" : "NON") << endl;
    return 0;
}

ainsi que ceci:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include <iostream>
#include <vector>
#include <functional>
#include <algorithm>
#include <boost/bind.hpp>
 
using namespace std;
 
class Foo
{
public:
	Foo(int val) : m_val(val) {}
	bool operator==(const Foo & foo) const { return (foo.m_val == m_val); }
 
private:
	int m_val;
};
 
struct SameAs
{
	SameAs( const Foo& val ) :
		m_val( val )
	{
	}
 
	bool operator()( const Foo& val2 )
	{
		return m_val == val2;
	}
 
private:
	const Foo& m_val;
};
 
int main()
{
    vector<Foo> vf;
    vf.push_back(Foo(1));
    vf.push_back(Foo(2));
    vf.push_back(Foo(3));
    vf.push_back(Foo(4));
    vf.push_back(Foo(5));
    typedef vector<Foo>::const_iterator VI;
    VI p = find_if(vf.begin(), vf.end(), SameAs( Foo(3) ));
    cout << ((p != vf.end()) ? "OUI " : "NON") << endl;
    return 0;
}

13/10/2009, 12h25
Trunks

En fait, je veux d'abord savoir bien utiliser la version non-boost.
Puis ensuite, j'apprendrai à me servir de la version boost.
En ce qui concerne le foncteur, je connaissais aussi, c'est juste que j'ai envie de comprendre pourquoi le std::bind ne marche pas dans cet exemple (si j'enlève la référence ou utilise des char *, ça fonctionne).
Pour info, j'utilise Code::Blocks.

Mais merci pour tes exemples :ccool:
13/10/2009, 12h39
JulienDuSud

Je crois que c'est une limitation de la STL à ce niveau là... C'est pourquoi je te conseille d'utiliser boost en attendant la nouvelle norme.

C'est une histoire de double référence, faut que tu fasses un wrapper autour de bind2nd pour que ça fonctionne...
13/10/2009, 12h42
Trunks

Merci pour ta réponse ;)
13/10/2009, 14h02
Goten

Ouai ça supporte pas les références donc t'as aussi std::tr1::bind si ton compilo le supporte. Ou alors utilisez boost::ref (pour éviter le wrapper)
13/10/2009, 14h56
camboui

J'avais soulevé la même frustration il y a quelques mois à propos des limites de bind2nd/1st avec les references.
Conclusion: foncteur à defaut de boost.