Re: Unexpected overload resolution under SFINAE conditions
On Mar 26, 7:45 am, "Greg Herlihy" <gre...@pacbell.net> wrote:
On Mar 25, 4:43 pm, "Daniel Kr?gler" <daniel.krueg...@googlemail.com>
My question is: Can Comeau be right here? I studied large parts
of 13.3/2-4, 13.3.1.1.1, 13.3.2, 13.3.3.1, 14.8.3, 14.8.2 including
a small promenade into 3.4(2), but could not find any evidence
for this outcome, but maybe my reading/interpretation is wrong.
?13.1/2 makes it clear that a function declaration may not be
overloaded by another function declaration that differs only in its
return type - yet this program overloads foo() with another a nearly-
identical foo() - that differs only in its return type. Therefore
Comeau is correct to report an error.
Note that due to SFINAE there will be only *one* of the
seemingly two overloads in the final overload set, because
depending on T the other one will be "masked". Furtheron
14.5.5.1/1 makes it clear that:
"It is possible to overload function templates so that two
different function template specializations have the same
type."
Going on with para 2-4:
"Such specializations are distinct functions and do not
violate the one definition rule (3.2).
The signature of a function template specialization
consists of the signature of the function template and
of the actual template arguments (whether explicitly
specified or deduced).
The signature of a function template consists of its
function signature, its return type and its template
parameter list."
That your point is not relevant here is also clearly
seen from my quoted error message:
Comeau does *not* choke about the two seemingly
equal overloads. A modified program, which *only*
uses the two SFINAE overloads is accepted even
by Comeau:
// #3 ---------------------------------------------------------
#include "Common.h"
template <class T>
typename enable_if<is_same<T, Other>::value>::type
foo(T&) { std::cout << "2a" << std::endl; }
template <class T>
typename enable_if<!is_same<T, Other>::value>::type
foo(T&) { std::cout << "2b" << std::endl;}
int main() {
Something<int> x;
foo(x); // Fine, chooses "2b"
}
// #3 ---------------------------------------------------------
Btw.: If your assumption would be true, Concept-based
overloading would not work anyway: It uses practically
the SFINAE ansatz and uses overload sets with the "same"
argument types (but not same signatures). Depending on
the actual argument only one remains as viable best
function overload and will be choosen.
I'm *not* looking for a workaround, I'm just trying to see
a loophole, which Comeau uses, that I do not see yet.
Btw, a possible *workaround* is to create a completely
SFINAEed overload set:
// #4 ---------------------------------------------------------
#include "Common.h"
template <typename T>
struct is_SomeThing { static const bool value = false; };
template <typename T>
struct is_SomeThing<Something<T> > { static const bool value =
true; };
template <class T>
typename enable_if<is_SomeThing<T>::value>::type
foo(T&){ std::cout << "1" << std::endl; }
template <class T>
typename enable_if<is_same<T, Other>::value>::type
foo(T&) { std::cout << "2a" << std::endl; }
template <class T>
typename enable_if<
!is_same<T, Other>::value &&
!is_SomeThing<T>::value>::type
foo(T&) { std::cout << "2b" << std::endl;}
int main() {
Something<int> x;
foo(x); // Fine, chooses "1"
}
// #4 ---------------------------------------------------------
Greetings from Bremen,
Daniel Kr?gler
---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:std-c++@ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]