Discussion :

[Florian Goo]

Salut à tous,

Je fais peu à peu mon deuil de la non inclusion des concepts dans C++0x en me penchant sur boost::concept_check, qui a finalement l'air intéressant.

Peut-on surcharger une fonction en utilisant concept_check et le mécanisme SFINAE ?
J'ai pensé que la simple utilisation de concept_check permettait ça (car tout est inclus dans la signature de la fonction), mais il semblerait que non :

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
#include <iostream>
#include <boost/concept_check.hpp>
#include <boost/concept/requires.hpp>
 
class integer
{
	public:
		integer(int value):
			value_(value)
		{
		}
 
		int
		value() const
		{
			return value_;
		}
 
	private:
		int value_;
};
 
bool
operator==(const integer& i, const integer& j)
{
	return i.value() == j.value();
}
 
template<typename T>
class Comparable
{
	public:
		BOOST_CONCEPT_USAGE(Comparable)
		{
			t1 == t2;
		}
 
	private:
		T t1;
		T t2;
};
 
template<typename T>
class JavaStyleComparable
{
	public:
		BOOST_CONCEPT_USAGE(JavaStyleComparable)
		{
			t1.equals(t2);
		}
 
	private:
		T t1;
		T t2;
};
 
template<typename T>
BOOST_CONCEPT_REQUIRES
(
	((Comparable<T>)),
	(bool)
)
same_value(const T& t1, const T& t2)
{
	return t1 == t2;
}
 
template<typename T>
BOOST_CONCEPT_REQUIRES
(
	((JavaStyleComparable<T>)),
	(bool)
)
same_value(const T& t1, const T& t2)
{
	return t1.equals(t2);
}
 
int
main()
{
	integer i(0);
	integer j(0);
 
	if(same_value(i, j))
	{
		std::cout << "woohoo!\n";
	}
	else
	{
		std::cout << "d'oh!\n";
	}
 
	return 0;
}

Code :

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

1
2
3
4
5
6
7
8
main.cpp|85| error: call of overloaded ‘same_value(integer&, integer&)’ is ambiguous
main.cpp|63| note: candidates are: typename boost::Requires_<(0 + boost::_requires_::value), void (*)(bool)>::type same_value(const T&, const T&) [with T = integer]
main.cpp|74| note:                 typename boost::Requires_<(0 + boost::_requires_::value), void (*)(bool)>::type same_value(const T&, const T&) [with T = integer]
|| main.cpp: In destructor ‘JavaStyleComparable<T>::~JavaStyleComparable() [with T = integer]’:
/usr/include/boost/concept/detail/general.hpp|29| instantiated from ‘static void boost::concept::requirement<Model>::failed() [with Model = JavaStyleComparable<integer>]’
/usr/include/boost/concept/requires.hpp|31| instantiated from ‘boost::_requires_<void (*)(JavaStyleComparable<integer>)>’
main.cpp|85| instantiated from here
main.cpp|49| error: ‘class integer’ has no member named ‘equals’

J'ai parcouru la doc et je n'ai pas vu un tel cas d'utilisation. On peut faire quelque chose en ajoutant du enable_if ? Si oui comment ?

[Florian Goo]

Bon. Déjà le couple concept_check/enable_if, c'est mouru :

on Wed Jan 30 2008, Johan Torp <johan.torp-AT-gmail.com> wrote:

> Is there any way to combine boost::enable_if and the concept check library?
> For instance to disable a function overload for template parameters which
> doesn't model some STL concept.

Nope. Those concepts perform checks that cause hard compile-time
errors. Once they've failed, it's too late to recover... and not all
concept check failures can be converted to non-error true/false results
in C++03.

http://lists.boost.org/Archives/boos.../01/132842.php


Et pour SFINAE tout court, j'en ai aussi bien l'impression.

[ptyxs]

Que veux-tu dire en ce qui concerne SFINAE ? C'est une technique de programmation comment ça pourrait "mouruir" ?

[Florian Goo]

Pardonne-moi mais je n'ai pas compris ta question ?

[Goten]

Que veux-tu dire en ce qui concerne SFINAE ? C'est une technique de programmation comment ça pourrait "mouruir" ?

Il parlait de l'utilisation conjointe de boost::enable_if et concept_check. C'est "mourru" dans le sens c'est pas possible .

Quand a flo : euh non là sur le coup jvois pas :s.

[Florian Goo]

J'ai causé un peu avec Alp et il m'a parlé de ça :
http://www.open-std.org/jtc1/sc22/wg...008/n2634.html
Du SFINAE pour les expressions.

Vu que le principe de concept_check (et en particulier de BOOST_CONCEPT_REQUIRES) est d'imposer une série d'instruction dans la signature de la fonction, ça m'a l'air d'être la bonne feature pour permettre une surcharge de fonctions comme je le souhaite et comme les concepts de C++0x le promettaient.
D'ailleurs loufoque en causait furtivement ici, mais ça m'est passé sous le nez : http://www.developpez.net/forums/d77...s/#post4520427

Y'a bon.

[Florian Goo]

Euh non attendez, pas du tout…
http://gcc.gnu.org/projects/cxx0x.html
GCC 4.4, qui est le compilo que j'utilise, implémente déjà la fonctionnalité « Solving the SFINAE problem for expressions ».

J'ai activé C++0x et l'erreur est toujours présente.


En me basant sur l'exemple donné dans le proposal, j'écris un code complet pour tester :

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#include <iostream>
 
struct X
{
	X(int value):
		value_(value)
	{
	}
 
	int value_;
};
 
X
operator*(X x1, X x2)
{
	return X(x1.value_ * x2.value_);
}
 
 
 
struct Y
{
	Y(int value):
		value_(value)
	{
	}
 
	int value_;
};
 
Y
operator+(Y y1, Y y2)
{
	return Y(y1.value_ + y2.value_);
}
 
 
 
template<class T>
auto
f(T t1, T t2) -> decltype(t1 + t2) // #1
{
	std::cout << "#1\n";
	return t1 + t2;
}
 
template<class T>
auto
f(T t1, T t2) -> decltype(t1 * t2) // #2
{
	std::cout << "#2\n";
	return t1 * t2;
}
 
int main()
{
	X x1(0), x2(0);
	X x3 = f(x1, x2); // deduction fails on #1 (cannot add X+X), calls #2
 
	Y y1(0), y2(0);
	Y y3 = f(y1, y2); // calls #1
}

Non seulement ça compile, mais en plus j'ai bien la sortie attendue :

Code :

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

1
2
#2
#1

Donc ça fonctionne bien.

On est obligé d'utiliser decltype, donc ?
Et si on veut surcharger une fonction qui renvoie void, on fait comment ?

[3DArchi]

Et si on veut surcharger une fonction qui renvoie void, on fait comment ?

Comme ça ?

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#include <iostream>
 
struct X
{
	X(int value):
		value_(value)
	{
	}
 
	int value_;
};
 
void
operator*(X x1, X x2)
{
	X(x1.value_ * x2.value_);
}
 
 
 
struct Y
{
	Y(int value):
		value_(value)
	{
	}
 
	int value_;
};
 
void
operator+(Y y1, Y y2)
{
	Y(y1.value_ + y2.value_);
}
 
 
 
template<class T>
auto
f(T t1, T t2) -> decltype(t1 + t2) // #1
{
	std::cout << "#1\n";
	return t1 + t2;
}
 
template<class T>
auto
f(T t1, T t2) -> decltype(t1 * t2) // #2
{
	std::cout << "#2\n";
	return t1 * t2;
}
 
int main()
{
	X x1(0), x2(0);
	f(x1, x2); // deduction fails on #1 (cannot add X+X), calls #2
 
	Y y1(0), y2(0);
	f(y1, y2); // calls #1
}

[Alp]

Tu t'en fous que ce soit void ou autre chose. void n'est qu'un type au milieu de tant d'autres.

Donc SFINAE pour les expressions bien qu'un poil différent des concepts va pas mal aider. Je ne savais pas que g++4.4 l'implémentait par contre, merci du tuyau ! Je vais voir pour rédiger un petit truc là-dessus

[Florian Goo]

Certes, mais si on est obligé de passer par auto/decltype, ça sera une bidouille bien cradingue…

[Florian Goo]

Je bidouille un peu, apparemment une signature type « auto/decltype » n'est pas requise :

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
template<typename>
class require
{
	public:
		typedef void* type;
};
 
//#1
template<class T>
T
f(T t1, T t2, typename require<decltype(t1 * t2)>::type = 0)
{
	std::cout << "#1\n";
	return t1 * t2;
}
 
//#2
template<class T>
T
f(T t1, T t2, typename require<decltype(t1 + t2)>::type = 0)
{
	std::cout << "#2\n";
	return t1 + t2;
}
 
int main()
{
	X x1(0), x2(0);
	Y y1(0), y2(0);
 
	X x3 = f(x1, x2); //calls #1
	Y y3 = f(y1, y2); //calls #2
}

C'est mieux .

[Florian Goo]

Puisque la question initiale a eu sa réponse et puisqu'il ne s'agit plus de Boost, je vous invite à continuer la discussion ici : http://www.developpez.net/forums/d84...r-expressions/
De plus, la visibilité du sujet n'en sera que meilleure !