Discussion :

[Trunks]

Voici un petit code test:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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?

[JulienDuSud]

Chez moi, ton code compile pas..

Par contre, ceci fonctionne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}

[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

[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...

[Trunks]

Merci pour ta réponse

[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)

[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.