Is this incorrect use of std::bind or a compiler bug?

Question

I am using the latest snapshot build of clang with latest TDM-Gcc headers and libs. When compiling this (using -std=c++11 flag):

#include <functional>
#include <iostream>

class Foo
{
    public:
        void Bar(int x)
        {
            std::cout << x << std::endl;
        }
};

int main()
{
    Foo foo;
    auto f = std::bind(&Foo::Bar, &foo, 5);
    f();
    return 0;
}

I get these errors:

In file included from Test.cpp:1:
C:\DevEnv\LLVM38\lib\gcc\mingw32\5.1.0\include\c++\functional:1426:7: error: static_assert failed "Wrong number of arguments for pointer-to-member"
      static_assert(_Varargs::value
      ^             ~~~~~~~~~~~~~~~
C:\DevEnv\LLVM38\lib\gcc\mingw32\5.1.0\include\c++\functional:1440:7: note: in instantiation of template class 'std::_Bind_check_arity<void (Foo::*)(int) __attribute__((thiscall)), Foo *, int>' requested here
    : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
      ^
C:\DevEnv\LLVM38\lib\gcc\mingw32\5.1.0\include\c++\functional:1461:5: note: in instantiation of template class 'std::_Bind_helper<false, void (Foo::*)(int) __attribute__((thiscall)), Foo *, int>' requested here
    _Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type
    ^
Test.cpp:16:14: note: while substituting deduced template arguments into function template 'bind' [with _Func = void (Foo::*)(int) __attribute__((thiscall)), _BoundArgs = <Foo *, int>]
    auto f = std::bind(&Foo::Bar, &foo, 5);
             ^
Test.cpp:16:14: error: no matching function for call to 'bind'
    auto f = std::bind(&Foo::Bar, &foo, 5);
             ^~~~~~~~~
C:\DevEnv\LLVM38\lib\gcc\mingw32\5.1.0\include\c++\functional:1490:5: note: candidate template ignored: couldn't infer template argument '_Result'
    bind(_Func&& __f, _BoundArgs&&... __args)
    ^
C:\DevEnv\LLVM38\lib\gcc\mingw32\5.1.0\include\c++\functional:1462:5: note: candidate template ignored: substitution failure [with _Func = void (Foo::*)(int) __attribute__((thiscall)), _BoundArgs = <Foo *, int>]
    bind(_Func&& __f, _BoundArgs&&... __args)
    ^
2 errors generated.

Am i misusing std::bind or is this some weird compiler error? It seems to compile fine using just TDM Gcc.

I wouldn't hurry to call bug that fast. Check your enviroment, I [believe](http://ideone.com/pTM1cN) there might be something off there. — A. Abramov, Aug 15 '15 at 22:52
I just made some fresh installs with the versions i mentioned above, after observing this behavior on the stable 3.6.2 clang build — Fr0stBit, Aug 15 '15 at 22:54
it builds and runs fine for me with clang-3.6, gcc 4.8.4, on linux mint. TheArtist: maybe you need to use clang libstdc++ with clang rather than the gcc standard headers and libs? I think that could make a difference. — Chris Beck, Aug 15 '15 at 23:01
Well clang's windows implementation to libstdc++ is not even closed to finished... — Fr0stBit, Aug 15 '15 at 23:08
It works for me even with Clang using the GCC headers in case this wasn't already clear. — 5gon12eder, Aug 15 '15 at 23:26
Excellent testcase (aside from the redundant `return 0` taking up space :P) — Lightness Races in Orbit, Aug 15 '15 at 23:37
@5gon12eder yes but does it work on Windows and with what versions? Cause you said about compilation on linux — Fr0stBit, Aug 16 '15 at 01:10

Lightness Races in Orbit · Accepted Answer · 2016-03-31T08:58:32.443

4

This code is fine.

Unless you've done something weird or unsupported with your installation, your toolchain has a bug.

To me it looks like it's not considering the second argument to std::bind to be the "this pointer", and thinks you're actually passing two arguments to Foo::Bar (which you're not), which you can't.

~~The next step is to raise this with the maintainers of your toolchain.~~

See https://llvm.org/bugs/show_bug.cgi?id=24372.

edited Mar 31 '16 at 08:58

answered Aug 15 '15 at 23:35

Lightness Races in Orbit

378,754
76
643
1,055

1

[It already was reported](https://llvm.org/bugs/show_bug.cgi?id=24372). It happens to me only with mingw32 headers and Clang x86, but it works fine with mingw64 headers and Clang x64. – Jetski S-type Mar 30 '16 at 23:49

Is this incorrect use of std::bind or a compiler bug?

1 Answers1