How to make a function template the least priority during ADL?

Question

I have a problem where I'd like to provide a generic version of a function foo which may only be applied when there is absolutely no other match for an invocation. How can I modify the following code such that last_resort::foo is a worse match for derived::type than base::foo? I'd like to find a solution which does not involve modifying the definition of bar and which would preserve the type of the argument of last_resort::foo.

#include <iostream>

namespace last_resort
{

template<typename T> void foo(T)
{
  std::cout << "last_resort::foo" << std::endl;
}

}

template<typename T> void bar(T)
{
  using last_resort::foo;
  foo(T());
}

namespace unrelated
{

struct type {};

}

namespace base
{

struct type {};

void foo(type)
{
  std::cout << "base::foo" << std::endl;
}

}

namespace derived
{

struct type : base::type {};

}

int main()
{
  bar(unrelated::type()); // calls last_resort::foo
  bar(base::type());      // calls base::foo
  bar(derived::type());   // should call base::foo, but calls last_resort::foo instead

  return 0;
}

MSalters · Answer 1 · 2011-09-30T23:47:02.577

3

This would be about as bad as it gets:

struct badParam { template <typename T> badParam(T t) { } };
namespace last_resort {
  void foo(badParam, int dummy = 0, ...) {
    std::cout << "last_resort::foo" << std::endl;
  }
}

You've got a user-defined conversion, a defaulted parameter and an unused ellipsis.

[edit]

Slight variant, to save T I moved the user-defined conversion to the dummy parameter:

struct badParam { 
    badParam() { }
    operator int() { return 42; }
};
namespace last_resort {
  template <typename T> void foo(T t, int dummy = badParam(), ...) {
    std::cout << "last_resort::foo" << std::endl;
  }
}

edited Sep 30 '11 at 23:47

answered Sep 30 '11 at 22:59

MSalters

173,980
10
155
350

Thanks. I think that adding just the ```badParam``` is enough to demote it, but it erases the type of ```T``` in the conversion. – Jared Hoberock Sep 30 '11 at 23:23
Well, for a last resort case, you can't generally rely on T anyway, because you get all the weird types. But saving it is hard. Template Argument Deduction doesn't produce those user-defined conversions. – MSalters Sep 30 '11 at 23:39
Ancient post, but random thought: How about using the original `badParam`, but making `badParam` a template type with a template argument value pointer to the actual function to invoke, which it does so in its constructor. – Yakk - Adam Nevraumont Sep 23 '14 at 17:51

score 1 · Answer 2 · answered Sep 30 '11 at 18:42

1

You can't do much about it. Both foo functions are in the overload set. But your last_resort one is a better match simply because it does not require a conversion unlike base::foo for derived::type(). Only in the case where two candidates are "equally good" judging by the parameters and possible conversions, a non-template is preferred.

answered Sep 30 '11 at 18:42

sellibitze

27,611
3
75
95

That's true, but I wonder if there is a way to introduce a "hidden" conversion into foo by augmenting it with some extra parameters with default values? – Jared Hoberock Sep 30 '11 at 18:49
I don't think it'll work. From what I can tell the "best" you can get is an ambiguity so that compilation fails. But maybe, I'm missing something, too. – sellibitze Sep 30 '11 at 18:53
The solution seems to be to decorate ```last_resort::foo```'s return type with something like ```disable_if_foo_exists::type```, which would use SFINAE to check for a free ```foo``` function. If one exists, ```last_resort::foo``` would get removed from the overload set. – Jared Hoberock Sep 30 '11 at 22:01

score 1 · Accepted Answer · edited May 23 '17 at 12:27

last_resort::foo can be removed from the overload set with disable_if. The idea is to disable last_resort::foo(T) if foo(T) is otherwise well-formed. This causes last_resort::foo(T) to be the worst match for foo:

namespace test
{

template<typename T> struct has_foo { ... };

}

namespace last_resort
{

template<typename T>
  struct disable_if_has_foo
    : std::enable_if<
        !test::has_foo<T>::value
      >
{};

template<typename T>
  typename disable_if_has_foo<T>::type foo(T)
{
  std::cout << "last_resort::foo" << std::endl;
}

}

The output:

$ g++ last_resort.cpp 
$ ./a.out 
last_resort::foo
base::foo
base::foo

This answer describes how to build a solution for checking for the existence of a function (foo) returning void.

JohnPS · Answer 4 · 2011-09-30T20:49:00.587

0

You can provide an overload of bar for type derived::type after the declaration of derived::type. This can be in namespace derived or not.

void bar(derived::type)
{
  foo(derived::type());
}

edited Sep 30 '11 at 20:49

answered Sep 30 '11 at 20:40

JohnPS

2,518
19
17

How to make a function template the least priority during ADL?

4 Answers4