Overloading STL function - c++

Question

I have a code like this:
set<array<int, 3>> s;
int ar[3] = {1,2,3};
s.insert(ar);
auto it = s.find(ar);
And the message of IDE that no instance of overloaded function insert/find. If I use std::array it is ok, ::insert and ::find work in the same way.
But what if i wanna use these C arrays T[N] or find function with std::array in set should return iterator if two of three elements equal. Or set::insert will not insert a new array if it is a permutation of exist, I mean s.insert({1,2,3}) - already added, s.insert({3,2,1}) - return iterator on {1,2,3}.
The question is how to overload STD functions? Not in this code especially but in general? Any link or real code example welcome. May be its a really simple question for experienced programmers) but there are a lot of examples of operator overloading, but no for STL. Thanks.

Answer 1

You cannot declare additional overloads for a member function of a class outside the class definition. The language does not provide syntax for it. Since you can't modify the class definition in the standard library headers, you cannot add additional overloads to them either.
Free functions in the std namespace may not be overloaded. There is syntax for it (the same way any overloads of free functions work), but doing so causes undefined behavior, because it is explicitly forbidden in the standard, see [namespace.std]/1.
What is usually (exceptions apply) allowed is to define template specializations for entities in the std namespace, but only if the specialization depends on a user-defined type and not for member functions, member function templates or member class templates. See the rest of the quoted and following paragraph linked above.
A common example where specialization inside the std namespace is used is std::hash for use as hash function in unordered associative containers:
struct my_type {
//...
};
namespace std {
template<>
struct hash<my_type> {
auto operator()(my_type const& x) const noexcept {
//...
}
};
}
But even something like that is not allowed if my_type is replaced by int*, int[3] or std::array<int, 3> or anything similar, because there is no dependence on a user-declared type.
If you want to make a std::array from a built-in array, you will be able to use std::to_array in C++20:
set<array<int, 3>> s;
int ar[3] = {1,2,3};
s.insert(std::to_array(ar));
auto it = s.find(std::to_array(ar));
Before C++20, you might have the function available as std::experimental::to_array in #include<experimental/array> or you can define it yourself (from cppreference.com; requires #include<type_traits>, #include<utility> and #include<cstddef>):
namespace detail {
template <class T, std::size_t N, std::size_t... I>
constexpr std::array<std::remove_cv_t<T>, N>
to_array_impl(T (&a)[N], std::index_sequence<I...>)
{
return { {a[I]...} };
}
}
template <class T, std::size_t N>
constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&a)[N])
{
return detail::to_array_impl(a, std::make_index_sequence<N>{});
}

Answer 2

About the other question - about permutations, i.e., that you want your set to find iterator to {1,2,3} when you look for a permutation of it.
Technically, you can do 2 things:
(1) make a specialized comparison operator for which permutations are equivalent. Or make a class that wraps std::array and implement its comparison operators this way.
(2) (preferred) simply sort your array before adding it to set and/or searching for it.
If you need its elements in original order, then I recomend to make utility class that contains both the original array and sorted version that it uses for comparisons.
If you also want to be able to add option for having multiple original while returning the exact one when it exists... then its more complicated. It can be done with some composite functions.

Answer 3

Just like #walnut said, you cannot declare additional overloads for a member function of a class outside the class definition. Other than encapsulate your own int<3> class, there is another work around - operator << override.
set<array<int, 3>>& operator << (set<array<int, 3>>& s, int ar[3])
{
array<int,3> ar2 { ar[0], ar[1], ar[2] };
s.insert(ar2);
return s;
}
It looks weird, but easy to use.
Now you can do this
set<array<int, 3>> s;
int ar[3] = {1,2,3};
s << ar;
However, if there is a bunch of functions you want to use in set against int[3] against array, It is better to define your own class / struct.
template <class T, int arsize>
struct MyFixedArray
{
T ar[arsize];
MyFixedArray(T _ar[arsize]) {
for (int i = 0; i < arsize; ++i)
ar[i] = _ar[i];
};
operator array<T, arsize>() const {
array<T, arsize> _ar;
for (int i = 0; i < arsize; ++i)
_ar[i] = ar[i];
return _ar;
};
};
and now you can use it freely everwhere
MyFixedArray<int, 3> myar(ar);
s.insert(myar);
auto it = s.find(myar);

Answer 4

I don't think that C++ gives you the right to do so. For more information, you may get this answer useful in your case.
I hope that helps your problem.