Re: How to default an undefined operation?
Am 06.09.2012 23:05, schrieb Ivan Godard:
As for "easy to figure out", call me dense but it sure wasn't easy for
me. Even Daniel's solution, while solving my problem with scoped
enums, does not provide a general solution to discovering whether a
particular operation is defined.
Well, you haven't ask it that way ;-)
So please prove it is easy: I challenge you to write the
generalization of my use case:
Write a template function taking a single argument of arbitrary
type. If that type defines member function "foo", call it; if it does
not define "foo" then call member function "bar"; if neither are
defined then fail with a suitable diagnostic.
Test case:
template<typename T> void fooOrBar(T t) {
/* you write this, with the following effect: */
if (defined(t.foo))
t.foo();
else
t.bar();
/* end of your code */
}
struct FOO { void foo() {}; };
struct BAR { void bar() {}; };
int main() {
FOO f;
BAR b;
fooOrBar(f);
fooOrBar(b);
return 0;
}
Your solution should work for any argument type for which "t.foo()" is
valid, including references and CV-qualified. Note that FOO and BAR
are supplied by third parties and your solution cannot change
them. Note also that foOrBar will be placed in a utility library and
so you cannot simply enumerate the list of possible argument types in
advance and write an overload for each.
I'm not sure that I properly understand your question, but it seems as
if you have to call the function foo or bar, so you need to know the
arguments you have to provide. In your snippet above you seem to assume
functions with no parameters.
From what I understand from your question, most parts should be quite
easy to realize with C++11 because of the extended sfinae capabilities.
Here is the result of a 7-min-coding:
#include <utility>
#include <type_traits>
template<class T, class... Args>
struct has_member_foo {
template<class U, class... Ws,
class = decltype(std::declval<U>().foo(std::declval<Ws>()...))
>
static std::true_type test(int);
template<class...>
static std::false_type test(...);
static constexpr bool value = decltype(test<T, Args...>(0))::value;
};
template<bool>
struct fooOrBarHelper {
template<class T, class... Args>
void operator()(T&& t, Args&&... args) {
std::forward<T>(t).foo(std::forward<Args>(args)...);
}
};
template<>
struct fooOrBarHelper<false> {
template<class T, class... Args>
void operator()(T&& t, Args&&... args) {
std::forward<T>(t).bar(std::forward<Args>(args)...);
}
};
template<typename T, class... Args>
void fooOrBar(T&& t, Args&&... args) {
fooOrBarHelper<has_member_foo<T, Args...>::value>()(
std::forward<T>(t), std::forward<Args>(args)...
);
}
For extra points, extend the problem to built in operators like
operator-, such that any argument for which "-t" is valid will apply
"-t" and otherwise will call "bar(t)". The extension should extend
support to unscoped enums and all arithmetic and pointer types.
Based on above example code it should be not to hard to realize this as
well, I'm pretty sure. I'm not sure what is meant by "should extend
support to unscoped enums and all arithmetic and pointer types". What
does extend mean here? In the trivial approach as outlined above the
unscoped enums would invoke the bar function. If this is not wanted you
have to introduce one further specialization of fooOrBarHelper catching
scoped enums.
HTH & Greetings from Bremen,
Daniel Kr?gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]