В общей функции я использую следующую идиому,
template<class It1, class It2>
void do_something(It1 first, It1 second, It2 d_first){
... other stuff here...
using std::copy;
copy(first, second, d_first);
}
do_something - это универсальная функция, которая не должна знать ничего конкретного о других библиотеках (кроме, возможно, std::.
Теперь предположим, что в моем пространстве имен N есть несколько итераторов.
namespace N{
struct itA{using trait = void;};
struct itB{using trait = void;};
struct itC{using trait = void;};
}
Я хочу перегрузить копию для этих итераторов в этом пространстве имен. Естественно, я бы сделал:
namespace N{
template<class SomeN1, class SomeN2>
SomeN2 copy(SomeN1 first, SomeN1 last, SomeN2 d_first){
std::cout << "here" << std::endl;
}
}
Однако, когда я вызываю do_something с аргументом N::A, N::B или N::C я получаю "неоднозначный вызов копирования", даже если они находятся в том же пространстве имен, что и N::copy.
Есть ли способ победить std::copy в контексте оригинальной функции выше?
Я думал, что если я наложу ограничения на аргументы шаблона, то N::copy будет предпочтительнее.
namespace N{
template<class SomeN1, class SomeN2, typename = typename SomeN1::trait>
SomeN2 copy(SomeN1 first, SomeN1 last, SomeN2 d_first){
std::cout << "here" << std::endl;
}
}
но это не помогает
Какие другие обходные пути можно использовать для общего вызова copy, чтобы предпочесть копию в пространстве имен аргументов, а не std::copy.
Полный код:
#include<iostream>
#include<algorithm>
namespace N{
struct A{};
struct B{};
struct C{};
}
namespace N{
template<class SomeN1, class SomeN2>
SomeN2 copy(SomeN1 first, SomeN1 last, SomeN2 d_first){
std::cout << "here" << std::endl;
}
}
template<class It1, class It2>
void do_something(It1 first, It1 second, It2 d_first){
using std::copy;
copy(first, second, d_first); // ambiguous call when It is from namespace N (both 'std::copy' and 'N::copy' could work.
}
int main(){
N::A a1, a2, a3;
do_something(a1, a2, a3);
}
Типичное сообщение об ошибке
error: call of overloaded 'copy(N::A&, N::A&, N::A&) is ambiguous
Правильно ли я считаю, что концепции C++ здесь помогут, предпочитая вызовы функций с большим количеством ограничений, чем с меньшими ограничениями?