Warum kann der Compiler nicht um die ungültige Verwendung der nicht statischen Elementfunktion herum arbeiten

Question

Ich brauchte einen Weg, wie die Ausführungszeit einer Funktion zu messen. Ich fand diese sehr gute Antwort auf SO https://stackoverflow.com/a/21995693/3179492. Es ist eine perfekte Lösung.

Es verwendet einen Funktionszeiger mit variadischen Parameterliste. Hier

ist die MCVE:

#include <algorithm> 
#include <chrono> 
#include <stdio.h> 

class Foo 
{ 
public: 
    auto foo_member(int x) -> void { printf("in foo_member(%d);\n", x); } 
}; 

class measure 
{ 
public: 
    template<typename F, typename ...Args> 
    static typename std::chrono::microseconds::rep execution(F func, Args&&... args) 
    { 
     auto start = std::chrono::system_clock::now(); 
     func(std::forward<Args>(args)...); 
     auto duration = std::chrono::duration_cast<std::chrono::microseconds> 
            (std::chrono::system_clock::now() - start); 
     return duration.count(); 
    } 
}; 

int main() 
{ 
     Foo foo; 
     int x = 1234; 

     // this line does not compile  
     printf("execution time=%ld\n", measure::execution(foo.foo_member, x)); 
} 

Dieser Code kompiliert nicht, weil foo_member nicht statisch ist. Die Fehlermeldung lautet invalid use of non-static member function.

Es gibt einige Möglichkeiten, wie Sie das Problem lösen können. Für mich ist die eleganteste, kürzeste und effektivste Weg ist dies:

printf("execution time=%ld\n", measure::execution([&foo, &x]() { foo.foo_member(x); })); 

Das heißt, ich habe eine Lambda-Funktion verwenden, um die Linie zusammengestellt zu bekommen.

Ich frage mich nur, warum der Compiler konnte es nicht für mich tun? Der Code Pfad ist genau definiert, wie die erste Version in eine Lambda-Funktion mit dem Capture-Mechanismus zu übersetzen. Wenn Sie erkennen, was ein moderner C++ Compiler mit dem Code zu tun wäre dies in der Tat sein, eine des einfachstenen Code Neuordnungs ...

Hinweis:

Es ist mit diesen gcc Fahnen zusammengestellt: -Wall -Werror -Wextra -std=c++11

Answer 1

foo_member ist eine nicht statische Elementfunktion, daher wird ein implizites erstes Argument benötigt, der this Zeiger, den Sie übergeben müssen. Die richtige Syntax zum Erstellen eines Zeigers für die Elementfunktion ist &ClassName::Func, nicht class_instance.Func.

Ihrem Beispiel zu beheben, folgende Änderungen vornehmen:

Innerhalb main

printf("execution time=%ld\n", measure::execution(&Foo::foo_member, &foo, x)); 

Jetzt sind Sie einen Zeiger auf Foo::foo_member, und einen Zeiger auf Foo Instanz als erstes Argument übergeben. foo_member wird für diese Instanz aufgerufen.

measure::execution muss geändert werden, um Zeiger auf Elementfunktionen korrekt zu behandeln. Der einfachste Weg, dies zu tun, um wahrscheinlich std::experimental::apply zu verwenden.

std::experimental::apply(func, std::forward_as_tuple(std::forward<Args>(args)...)); 

Oder wenn Sie einen C++ 17-Compiler haben, können Sie verwenden std::invoke, in dem Fall, dass Sie den Anruf zu forward_as_tuple vermeiden können.

Live demo (mit std::experimental::apply)

Live demo (mit std::invoke)

Answer 2

Sie streiten für das Hinzufügen von völlig neue Syntax zu tun, was bereits in vielerlei Hinsicht getan werden kann.Die einfachste Lösung ist die Verwendung mem_fn:

measure::execution(std::mem_fn(&Foo::foo_member), foo, x) 

Sie auch std::bind oder boost::bind verwenden:

using std::placeholders; 
measure::execution(std::bind(&Foo::foo_member, foo, _1), x)