如何讓ADL更喜歡功能模板到另一個

Question

我想知道是否有可能讓ADL選擇在其中一個參數（或在其他一些明確定義的地方）的類的命名空間中定義的函數模板當其他功能模板可見時的情況。我有一個激勵的例子，儘管我知道這個特定案例的解決方法（我在下面討論），但總的來說這個問題似乎是有道理的。

我覺得挺酷的，以避免使用朋友的聲明，而是工作委託給方法，從而想出了

namespace n 
    { 
    struct a 
    { 
    auto swap(a& a2) -> void; 
    }; 
    auto swap(a& a1, a& a2) -> void 
    { 
    a1.swap(a2); 
    } 
    } 
auto main(void) -> int 
    { 
    n::a a1, a2; 
    using std::swap; 
    swap(a1,a2); // use case 1 
    n::swap(a1,a2); // use case 2 
    } 

到目前爲止，一切都很好，都使用的情況下正常工作，但後來，我加入用自己的交換方法的第二類，並決定通過轉動獨立交換到模板上樣板保存：

namespace n 
    { 
    struct a 
    { 
    auto swap(a& a2) -> void; 
    }; 
    struct b 
    { 
    auto swap(b& b2) -> void; 
    }; 
    template<class T> 
    auto swap(T& t1, T& t2) -> void 
    { 
    t1.swap(t2); 
    } 
    } 
auto main(void) -> int 
    { 
    n::a a1, a2; 
    using std::swap; 
    swap(a1,a2); // use case 1 
    n::swap(a1,a2); // use case 2 
    } 

這裏使用的情況下1條斷裂時，編譯器抱怨與std::swap模板歧義。如果一個預期的問題，它可以定義swap功能rahter比方法（它們通常是朋友，因爲他們更換方法）：

namespace n 
    { 
    struct a 
    { 
    friend auto swap(a& a1, a& a2) -> void; 
    }; 
    struct b 
    { 
    friend auto swap(b& b1, b& b2) -> void; 
    }; 
    } 

現在一切正常，所以在swap的情況下，它是剛夠要記住使用比方法更好的朋友函數，但一般情況如何？是否有任何黑客，無論是骯髒的，這將讓編譯器明確地選擇n::foo<a>（或在我們控制下的其他一些foo<a>）在其他template<class T> foo可見的情況下，無論是在全局命名空間還是由於某些using子句，特別是如果後者是不是我們的修改？

Answer 1

這裏的罪魁禍首不只是你寫using std::swap，但從根本上說你提供你自己無限制的函數模板swap每當namespace std被名稱查找時認爲會給超載分辨率誤差與std::swap（無論是由明確的using指令或ADL）。

舉例說明：剛剛離開了using std::swap會來救你在這種情況下

Live On Coliru

auto main() -> int 
{ 
    n::a a1, a2; 
    swap(a1,a2); // use case 1 
    n::swap(a1,a2); // use case 2 
} 

但是假設你重構你的類a和b成類模板b<T>和b<T> ，並使用來自namespace std的模板參數（例如std::string）調用它們，然後你得到一個重載解析錯誤：

Live On Coliru

#include <iostream> 
#include <string> 

namespace n 
{ 

template<class>  
struct a /* as before */; 

template<class> 
struct b /* as before */; 

} 

auto main() -> int 
{ 
    n::a<std::string> a1, a2; // oops, ADL will look into namespace std 
    swap(a1,a2); // use case 1 (ERROR) 
    n::swap(a1,a2); // use case 2 (OK) 
} 

結論：如果你定義自己的swap版本相同的簽名std::swap（只要重載關注）始終限定對它的調用以禁用ADL。

提示：更重要的是，不要偷懶，只是提供自己的swap功能（不是函數模板），每類在自己的名稱空間。

又見this Q&A通過這種類似的機制，爲什麼這是一個壞主意，提供自己的begin和end模板，並期望他們與ADL工作解釋。

Answer 2

我知道我必須看起來很傻，才能回答我自己的問題，但發佈它的事實和討論確實給我帶來了一些新的理解。

在反思，我們應該首先打了我，是序列

using std::swap; 
swap(a1,a2); 

真是太舊帽子，它顯然一定是錯誤的，因爲反覆使用它需要一個複製粘貼算法（使用using然後交換）。即使算法是雙線程的，你也不應該複製粘貼。那麼有什麼可以做得更好呢？怎麼樣把它變成一個班輪：

stdfallback::do_swap(a1,a2); 

讓我提供允許該代碼：

namespace stdfallback 
    { 

     template<class T> 
    auto lvalue(void) -> typename std::add_lvalue_reference<T>::type; 


     template <typename T> 
    struct has_custom_swap 
    { 
     template<class Tp> 
    using swap_res = decltype(swap(lvalue<Tp>(),lvalue<Tp>())); 

     template <typename Tp> 
    static std::true_type test(swap_res<Tp> *); 

     template <typename Tp> 
    static std::false_type test(...); 

    static const bool value = decltype(test<T>(nullptr))::value; 
    }; 


     template<class T> 
    auto do_swap(T& t1, T& t2) -> typename std::enable_if<has_custom_swap<T>::value,void>::type 
    { 
    swap(t1,t2); 
    } 

     template<class T> 
    auto do_swap(T& t1, T& t2) -> typename std::enable_if<!has_custom_swap<T>::value,void>::type 
    { 
    std::swap(t1,t2); 
    } 
    } 

在你找到一個基於SFINAE-traits類has_custom_swap其value的解決方案是真還是取決於是否發現了非交換的實例化類型的左值交換的非限定調用（對於那個需要lvalue模板，類似於declval但解析爲l值而不是r值），然後是do_swap方法的兩個重載自定義交換的情況現在，當它不是。必須調用它們不同於swap，否則調用非限定定製交換的那個不會被編譯，因爲它本身對它嘗試調用的交換不明確。

所以，也許我們應該考慮使用這種模式，而不是建立的using？

（要給予適當的信貸，性狀溶液通過http://blog.quasardb.net/sfinae-hell-detecting-template-methods/啓發）