mjhjmtu

One possible solution is to use another function template name and type discriminators to allow argument-dependent name lookup to find the associated function in the namespace of the arguments:

template<class T> struct Tag ;
template<class T> Tag<void> tag(T const&);

template<class It1, class It2>
void mycopy(It1 first, It1 second, It2 d_first, Tag<void>) 
 std::cout << "std::copyn";


template<class It1, class It2>
void mycopy(It1 first, It1 second, It2 d_first) 
 mycopy(first, second, d_first, decltype(tag(first))); // Discriminate by the type of It1.


namespace N

 struct itAusing trait = void;;
 Tag<itA> tag(itA);

 template<class It1, class It2>
 void mycopy(It1 first, It1 second, It2 d_first, Tag<itA>) 
 std::cout << "N::mycopyn";
 


int main() 
 char* p = 0;
 mycopy(p, p, p); // calls std::copy

 N::itA q;
 mycopy(q, q, q); // calls N::mycopy

This seems to fulfill your requirements:

namespace SpecCopy 

template <typename A, typename B, typename C>
void copy(A &&a, B &&b, C &&c) 
 std::copy(std::forward<A>(a), std::forward<B>(b), std::forward<C>(c));




template<class It1, class It2>
void do_something(It1 first, It1 second, It2 d_first)
 using namespace SpecCopy;
 copy(first, second, d_first);

Basically, it depends on ADL. If no function found by ADL, then it will use SpecCopy::copy, which is a wrapper to std::copy.

So, if you do:

N::A a1, a2, a3;
do_something(a1, a2, a3);

Then do_something will call N::copy.

If you do:

std::vector<int> a1, a2;
do_something(a1.begin(), a1.end(), a2.begin());

Then do_something will call SpecCopy::copy, which will call std::copy.

If you do:

int *a1, *a2, *a3;
do_something(a1, a2, a3);

Then same thing happens as before: do_something will call SpecCopy::copy, which will call std::copy.

In c++ 11 you could use tag dispatch. If you can make a little change to your custom iterators things will be a bit simpler to implement.

#include <iostream>
#include <algorithm>
#include <vector>
#include <type_traits>

// indicates that the type doesn't have a tag type (like pointers and standard iterators)
struct no_tag;

namespace detail 

 template <typename T>
 auto tag_helper(int) -> typename T::tag;

 template <typename>
 auto tag_helper(long) -> no_tag;


// get T::tag or no_tag if T::tag isn't defined.
template <typename T>
using tag_t = decltype(detail::tag_helper<T>(0));

namespace N

 struct my_iterator_tag ;
 struct A using tag = my_iterator_tag; ;
 struct B using tag = my_iterator_tag; ;
 struct C using tag = my_iterator_tag; ;


namespace N

 template<class SomeN1, class SomeN2>
 SomeN2 copy_helper(SomeN1 first, SomeN1 last, SomeN2 d_first, no_tag)
 
 std::cout << "calling std::copyn";
 return std::copy(std::forward<SomeN1>(first), std::forward<SomeN1>(last), std::forward<SomeN2>(d_first));
 

 template<class SomeN1, class SomeN2>
 SomeN2 copy_helper(SomeN1 first, SomeN1 last, SomeN2 d_first, my_iterator_tag)
 
 // your custom copy 
 std::cout << "custom copy functionn";
 return ;
 

 template<class SomeN1, class SomeN2>
 SomeN2 copy(SomeN1 first, SomeN1 last, SomeN2 d_first)
 
 return copy_helper(std::forward<SomeN1>(first), std::forward<SomeN1>(last), std::forward<SomeN2>(d_first), tag_t<SomeN1>);
 


template<class It1, class It2>
void do_something(It1 first, It1 second, It2 d_first)

 N::copy(first, second, d_first);


int main()

 N::A a1, a2, a3;
 std::cout << "using custom iterator: ";
 do_something(a1, a2, a3); 

 std::cout << "using vector iterator: ";
 std::vector<int> v;
 do_something(std::begin(v), std::end(v), std::begin(v));

 std::cout << "using pointer: ";
 int* ptr = new int[10];
 do_something(ptr, ptr + 5, ptr);

 return 0;

First we change our custom iterators to have a tag type (maybe change the name to avoid confusion with iterator_category). tag can be any type you want, it just has to match the type you use as tag in copy_helper.

Next, we define a type that allows us to access this tag type, or to fall back to a default type if tag doesn't exist. This will help us distinguish between our custom iterators and standard iterators and pointers. The default type I use is no_tag. The tag_t provides us with this functionality by using SFINAE and overload resolution. We call the function tag_helper(0) which has two declarations. The first one returns T::tag while the second one returns no_tag. Calling tag_helper(0) will always try to use the first version because int is a better match for 0 than long. This means we will always try to access T::tag first. However if this isn't possible (T::tag is not defined) SFINAE kicks in and skipps tag_helper(int) selecting tag_helper(long).

Finally, we just have to implement a copy function for each tag (I called it copy_helper) and another copy function as a wrap around for convinience (I used N::copy). The wrapper function then creates the proper tag type and calls the correct helper function.

Here is a live example.

Edit

If you move the code around a bit you can disconnect namespace N and rely on ADL:

#include <iostream>
#include <algorithm>
#include <vector>
#include <type_traits>

// indicates that the type doesn't have a tag type (like pointers and standard iterators)
struct no_tag;

namespace detail 

 template <typename T>
 auto tag_helper(int) -> typename T::tag;

 template <typename>
 auto tag_helper(long) -> no_tag;


// get T::tag or no_tag if T::tag isn't defined.
template <typename T>
using tag_t = decltype(detail::tag_helper<T>(0));

namespace N

 struct my_iterator_tag ;
 struct A using tag = my_iterator_tag; ;
 struct B using tag = my_iterator_tag; ;
 struct C using tag = my_iterator_tag; ;

 template<class SomeN1, class SomeN2>
 SomeN2 copy_helper(SomeN1 first, SomeN1 last, SomeN2 d_first, my_iterator_tag)
 
 // your custom copy 
 std::cout << "custom copy functionn";
 return ;
 


template<class SomeN1, class SomeN2>
SomeN2 copy_helper(SomeN1 first, SomeN1 last, SomeN2 d_first, no_tag)

 std::cout << "calling std::copyn";
 return std::copy(std::forward<SomeN1>(first), std::forward<SomeN1>(last), std::forward<SomeN2>(d_first));


template<class It1, class It2>
void do_something(It1 first, It1 second, It2 d_first)

 copy_helper(std::forward<It1>(first), std::forward<It1>(second), std::forward<It2>(d_first), tag_t<It1>);


int main()

 N::A a1, a2, a3;
 std::cout << "using custom iterator: ";
 do_something(a1, a2, a3); 

 std::cout << "using vector iterator: ";
 std::vector<int> v;
 do_something(std::begin(v), std::end(v), std::begin(v));

 std::cout << "using pointer: ";
 int* ptr = new int[10];
 do_something(ptr, ptr + 5, ptr);

 return 0;

OK, building on @paler123, but without checking for an existing type, but checking if It1 is a pointer instead:

namespace N
 struct A;
 struct B;
 struct C;


namespace N
 template<class SomeN1, class SomeN2>
 SomeN2 copy(SomeN1, SomeN1, SomeN2 c)
 std::cout << "here" << std::endl;
 return c;
 

template<class It1, class It2>
void do_something(It1 first, It1 second, It2 d_first)
 if constexpr (std::is_pointer_v<It1>) 
 std::copy(first, second, d_first);
 
 else
 
 copy(first, second, d_first);
 



int main()
 N::A a1, a2, a3;
 do_something(a1, a2, a3); 

 int* b1, *b2, *b3;

 do_something(b1, b2, b3); 

Still C++17, but in the case of pointers, we go through the explicit std::copy otherwise, we rely on ADL.

In general, your issue is a design problem. You want to use std::copy for all cases, except for objects from N, and in that case, you hope that ADL will work. But as you forced std::copy, you remove the option for proper ADL. You can't have everything and you have to redesign your code.

(These notes are now integrated in my edit to @sebrockm's answer)

For discussion I will write an answer to my own question with an alternative option.

It is not very nice because it needs to wrap all the N:: classes in another template class (called wrap here). The good thing is that do_something nor the N classes need to know about the special N::copy. The price is that the main caller has to explicitly wrap the N:: classes which is ugly but which is fine from the point of view of coupling because this is the only code that should know about the whole system.

#include <iostream>
#include <algorithm>
#include <vector>

namespace N
 struct A;
 struct B;
 struct C;


namespace N

 template<class S> struct wrap : S;

 template<class SomeN1, class SomeN2>
 SomeN2 copy(wrap<SomeN1> first, wrap<SomeN1> last, wrap<SomeN2> d_first)
 
 std::cout << "here" << std::endl;
 return d_first;
 


template<class It1, class It2>
void do_something(It1 first, It1 second, It2 d_first)
 using std::copy;
 copy(first, second, d_first);


int main()
 N::wrap<N::A> a1, a2, a3;
 std::cout << "do something in N:" << std::endl;
 do_something(a1, a2, a3); 

 std::vector<int> v = 1,2,3;
 std::vector<int> v2(3);
 std::cout << "do something in std:" << std::endl;
 do_something(std::begin(v), std::end(v), std::begin(v2));
 for (int i : v2)
 std::cout << i;
 std::cout << std::endl;

Suggest you have a look at the very powerful new Boost.HOF library.

This function does exactly what you want:

#include <boost/hof.hpp>

template<class It1, class It2>
void do_something(It1 first, It1 second, It2 d_first)
 namespace hof = boost::hof;

 auto my_copy = hof::first_of(
 (auto first, auto second, auto d_first) -> decltype(N::copy(first, second, d_first))
 
 return N::copy(first, second, d_first);
 ,
 (auto first, auto second, auto d_first) -> decltype(std::copy(first, second, d_first))
 
 return std::copy(first, second, d_first);
 );
 my_copy(first, second, d_first);

hof::first_of will select the first lambda whose return type is deduced to be the result type of a legal expression.