std::set deduction guide doesn't work as expected - c++17

Question

Shouldn't the two set types be identical?
#include <array>
#include <set>
#include <iostream>
template <class Iter>
std::set(Iter, Iter) -> std::set<typename std::iterator_traits<Iter>::value_type>;
int main() {
std::array a {1,2,3,4};
std::set<int> si {a.begin(), a.end()};
std::set s {a.begin(), a.end()};
for(auto& i: si) { std::cout << i << "\n"; }
for(auto& i: s ) { std::cout << i << "\n"; }
}
instead it yields:
1
2
3
4
0x7ffdf5bc9050
0x7ffdf5bc9060
even tried with additional Allocator :-(

Answer 1

There are two points of confusion here.
First, deduction guides must be in the scope of the class template that they're guiding, so this guide will just never be considered:
template <class Iter>
std::set(Iter, Iter) -> std::set<typename std::iterator_traits<Iter>::value_type>;
It would have to look like this:
namespace std {
template <class Iter>
set(Iter, Iter) -> set<typename iterator_traits<Iter>::value_type>;
}
But you're not allowed to add things into namespace std, so don't do that. And besides, this deduction guide already exists for set:
template<class InputIt,
class Comp = std::less<typename std::iterator_traits<InputIt>::value_type>,
class Alloc = std::allocator<typename std::iterator_traits<InputIt>::value_type>>
set(InputIt, InputIt, Comp = Comp(), Alloc = Alloc())
-> set<typename std::iterator_traits<InputIt>::value_type, Comp, Alloc>;
So there's no reason to add your version anyway.
The reason that deduction guide isn't used, nor would yours be if you put it in the right namespace, is the usual major caveat for list-initialization:
If there is a matching initializer_list<T> constructor, it is strongly preferred to anything else.
The specific language rule is that we do overload resolution specifically for those constructors first, and then we do the rest. And one of the other deduction guides in our list is:
template<class Key, class Comp = std::less<Key>, class Alloc = std::allocator<Key>>
set(std::initializer_list<Key>, Comp = Comp(), Alloc = Alloc())
-> set<Key, Comp, Alloc>;
Note that:
std::set s{a.begin(), a.end()};
is the exact same kind of construction as:
std::set u{1, 2};
Just because our two elements of the same type are iterators, doesn't mean they get treated any differently from any other two elements of the same type. So we get a set of iterators.
If you want to use the other deduction guide with the other constructor, you must use parentheses:
std::set s(a.begin(), a.end());
And remove your deduction guide!

Answer 2

std::set provides a constructor which takes a std::initializer_list and is able to do the type deduction of T for std::set<T>. In this case, using the syntax std::set x{a.begin(), a.end() }; will use the initializer list constructor and deduces T from that. No user defined deduction guide takes place!
If you create your object with std::set x(a.begin(), a.end()); the initilizer list constructor will not be used. Now, as no other constructor matches, deduction guides take place!
Example how the effect is if you have initializer list constructors in your code:
template < typename U >
struct X
{
// Directly makes the type deducable, because U can be deduced from the parameter of the constructor
X( std::initializer_list<U> )
{
std::cout << __PRETTY_FUNCTION__ << std::endl;
}
template < typename ... T>
X( T... )
{
std::cout << __PRETTY_FUNCTION__ << std::endl;
}
};
struct ONE {};
template < typename Iter >
X( const Iter&, const Iter& ) -> X<ONE>;
template < typename U >
struct Y
{
// type U can NOT deduced from the parameter!
template < typename T>
Y( std::initializer_list<T> )
{
std::cout << __PRETTY_FUNCTION__ << std::endl;
}
template < typename ... T>
Y( T... )
{
std::cout << __PRETTY_FUNCTION__ << std::endl;
}
};
struct TWO {};
template < typename Iter >
Y( const Iter&, const Iter& ) -> Y<TWO>;
int main()
{
std::array a {1,2,3,4};
X x1{a.begin(), a.end()};
X x2(a.begin(), a.end());
std::cout << "###" << std::endl;
Y y1{a.begin(), a.end()};
Y y2(a.begin(), a.end());
}
That initializer list constructors are take preference over deduction guide was also new to me and answered here:
Why does using uniform initializer syntax result in different behavior to the "old" style ()?
The important new thing for me was:
[over.match.list]
[...] overload resolution selects the constructor in two phases:
Initially, the candidate functions are the initializer-list constructors ([dcl.init.list]) of the class T and the argument list
consists of the initializer list as a single argument.
[...]
For details details see the linked question!