Warum verbietet der C++-Standard eine solch abscheuliche Verwendung nicht?

Question

Der Quellcode ist sehr einfach und selbsterklärend. Die Frage ist im Kommentar enthalten.

#include <iostream>
#include <functional>

using namespace std;
using namespace std::tr1;

struct A
{
    A()
    {
        cout << "A::ctor" << endl;
    }

    ~A()
    {
        cout << "A::dtor" << endl;
    }

    void foo()
    {}
};

int main()
{
    A a;
    /*
    Performance penalty!!!

    The following line will implicitly call A::dtor SIX times!!! (VC++ 2010)    
    */
    bind(&A::foo, a)();  

    /*
    The following line doesn't call A::dtor.

    It is obvious that: when binding a member function, passing a pointer as its first 
    argument is (almost) always the best way. 

    Now, the problem is: 

    Why does the C++ standard not prohibit bind(&SomeClass::SomeMemberFunc, arg1, ...) 
    from taking arg1 by value? If so, the above bind(&A::foo, a)(); wouldn't be
    compiled, which is just we want.
    */
    bind(&A::foo, &a)(); 

    return 0;
}

Answer 1

Zunächst einmal gibt es eine dritte Alternative zu Ihrem Code:

bind(&A::foo, std::ref(a))(); 

Warum werden nun die Parameter standardmäßig von der Kopie übernommen? Ich vermute, aber das ist nur eine wilde Vermutung, dass es als vorteilhaft angesehen wird für bind Standardverhalten, um unabhängig von der Lebensdauer der Parameter zu sein: Das Ergebnis einer Bindung ist ein Funktor, dessen Aufruf lange nach der Zerstörung der Parameter verzögert werden kann.

Würden Sie von folgendem Code erwarten, dass er UB standardmäßig ?

void foo(int i) { /* ... */ }

int main()
{
    std::function<void ()> f;

    {
        int i = 0;
        f = std::bind(foo, i);
    }

    f(); // Boom ?
}

Answer 2

Der Auftrag von C++ besteht nicht darin, das Schreiben von langsamem Code unmöglich zu machen oder gar zu erschweren. Es geht lediglich darum, dass Sie den Schnickschnack ausdrücklich anfordern müssen.