namespace std{

template<>
inline void swap(ole_lib::TConnectData2& x1,ole_lib::TConnectData2& x2)
{
 x1.swap(x2);
}//swap

}//nms std

Error C2912 explicit specialization 'void std::swap<ole_lib::TConnectData2>(ole_lib::TConnectData2 &,ole_lib::TConnectData2 &)' is not a specialization of a function template

template <class _Ty, class>
void swap(_Ty& _Left, _Ty& _Right) noexcept(is_nothrow_move_constructible_v<_Ty>&& is_nothrow_move_assignable_v<_Ty>) {
    _Ty _Tmp = _STD move(_Left);
    _Left    = _STD move(_Right);
    _Right   = _STD move(_Tmp);
}

namespace std{

inline void swap(ole_lib::TConnectData2& x1,ole_lib::TConnectData2& x2)
{
 x1.swap(x2);
}//swap

}//nms std

КД>Дык, научили же так. Лет 15 назад в сети увидел и начал делать так же

КД>Ну, спасибо что хоть не по голове ногами

        // FUNCTION TEMPLATE swap
#if _HAS_CXX17
template<class _Ty,
    class = enable_if_t<is_move_constructible_v<_Ty>
        && is_move_assignable_v<_Ty>>> inline
#else /* _HAS_CXX17 */
template<class _Ty,
    class = void> inline
#endif /* _HAS_CXX17 */
    void swap(_Ty&, _Ty&)
        _NOEXCEPT_COND(is_nothrow_move_constructible_v<_Ty>
            && is_nothrow_move_assignable_v<_Ty>);

template<class T,class>
void CALL(T &t, T &a)
{
}

struct A{int c;}a,b;

int main()
{
    
    CALL(a,b); // CLASS<A,A>(a,b); или нужен =void в шаблон
    return 0;
}

КД>namespace std{

КД>template<>
КД>inline void swap(ole_lib::TConnectData2& x1,ole_lib::TConnectData2& x2)
КД>{
КД> x1.swap(x2);
КД>}//swap

КД>}//nms std
КД>

16.5.4.2.1 Namespace std [namespace.std]
1 Unless otherwise specified, the behavior of a C++ program is undefined if it adds declarations or definitions
to namespace std or to a namespace within namespace std.

КД>Может я и раньше неправильно её определял?

The correct usage of customization points like swap is to first bring the standard swap into scope with a using declaration, and then to call swap unqualified:

using std::swap;
swap(a, b);

One problem with this approach is that it is error-prone. It is all too easy to call (qualified) std::swap in a generic context, which is potentially wrong since it will fail to find any user-defined overloads.

Unless explicitly prohibited, a program may add a template specialization for any standard library class template to namespace std provided that (a) the added declaration depends on at least one program-defined type and (b) the specialization meets the standard library requirements for the original template.173

The behavior of a C++ program is undefined if it adds declarations or definitions to namespace std or to a namespace within namespace std unless otherwise specified. A program may add a template specialization for any standard library template to namespace std only if the declaration depends on a user-defined type and the specialization meets the standard library requirements for the original template and is not explicitly prohibited.176

КД>Блин, я только-только изничтожил глобальный "using namespace std" (и не только) и начал явно указывать std::, как опять это объявляется неправильным

The template function boost::swap allows the values of two variables to be swapped, using argument dependent lookup to select a specialized swap function if available. If no specialized swap function is available, std::swap is used.