Template with make_shared started failing with c++20 and libc++

[brendandahl]

This was previously compiling with c++17. It also works with libstdc++/c++20 and msvc/c++20.

#include <memory>

class Foo {
public:
    Foo(int i) {}
};

template<typename Callable>
void constructor(Callable callable) {}

int main() {
    // std::shared_ptr<Foo> (*)(int &&)
    constructor(&std::make_shared<Foo, int>);
}

Flags: -stdlib=libc++ -std=c++20 main.cpp

Error:

main.cpp:15:5: error: no matching function for call to 'constructor'
   15 |     constructor(&std::make_shared<Foo, int>);
      |     ^~~~~~~~~~~
main.cpp:9:6: note: candidate template ignored: couldn't infer template argument 'Callable'
    9 | void constructor(Callable callable) {
      |      ^
1 error generated.

[philnik777]

Taking the address of non-addressable library functions is UB. If you don't do that it works as expected: https://godbolt.org/z/MPc7r45Wh

[brendandahl]

Didn't realize that was UB.

I'm curious though. Why does the following work (no int arg)?

#include <memory>

class Foo {
public:
    Foo() {}
};

template<typename Callable>
void constructor(Callable callable) {}

int main() {
    constructor(&std::make_shared<Foo>);
}

[philnik777]

I said UB before, but it's actually "unspecified, possibly ill-formed behaviour". So if it compiles it's most likely what you expect it to be. The result is the same though. Your second example happens to work because you don't get the make_unique overload for bounded arrays. They are guarded with a class = enable_if_t<...> template argument. So your first case will probably work when I refactor the code at some point to change it to enable_if_t<..., int> = 0. You should still avoid taking the address of functions though, since that can trivially break at some point. Maybe I'll find some time to add a warning for that in the future.

[ldionne]

Closing since the code is not standards conforming, as explained above.