Fehler: die Verwendung der Funktion gelöscht. Warum?

Ich versuche, eine Funktion erstellen, gilt ein beliebiger Funktor F zu jedem element eines bereitgestellten Tupel:

#include <functional>
#include <tuple>

//apply a functor to every element of a tuple
namespace Detail {

template <std::size_t i, typename Tuple, typename F>
typename std::enable_if<i != std::tuple_size<Tuple>::value>::type
ForEachTupleImpl(Tuple& t, F& f)
{
    f(std::get<i>(t));
    ForEachTupleImpl<i+1>(t, f);
}

template <std::size_t i, typename Tuple, typename F>
typename std::enable_if<i == std::tuple_size<Tuple>::value>::type
ForEachTupleImpl(Tuple& t, F& f)
{
}

}

template <typename Tuple, typename F>
void ForEachTuple(Tuple& t, F& f)
{
    Detail::ForEachTupleImpl<0>(t, f);
}

struct A
{
    A() : a(0) {}
    A(A& a) = delete;
    A(const A& a) = delete;

    int a;
};

int main()
{
    //create a tuple of types and initialise them with zeros
    using T = std::tuple<A, A, A>;
    T t;

    //creator a simple function object that increments the objects member
    struct F
    {
        void operator()(A& a) const { a.a++; }
    } f;

    //if this works I should end up with a tuple of A's with members equal to 1
    ForEachTuple(t, f);
    return 0;
}

Live-code-Beispiel: http://ideone.com/b8nLCy

Ich will nicht, um Kopien zu erstellen von A weil könnte es teuer werden (natürlich in diesem Beispiel ist es nicht) gelöscht da ich den copy-Konstruktor. Wenn ich das obige Programm habe ich bekommen:

/usr/include/c++/4.8/tuple:134:25: error: use of deleted function ‘A::A(const A&)’
       : _M_head_impl(__h) { }

Ich weiß, dass der Konstruktor wird gelöscht (das war absichtlich), aber was ich nicht verstehe, ist, warum es wird versucht, Kopien von meiner Struktur. Warum ist das passiert und wie kann ich das erreichen, ohne Sie zu kopieren A?

Gibt es nicht eine Art von call-stack, der zeigt, was versucht, das Tupel copy-Konstruktor?
Denn dies ist ein boost-Verwandte Frage, ich würde vorschlagen, das hinzufügen der boost-tag.
Es ist wirklich nicht. Es ist eine Frage, warum std::tuple versucht zu kopieren Ihrer Mitglieder in den ersten Platz.
Ist dies verursacht durch T t(0,0,0); oder durch ForEachTuple(t,f); oder in der ForEachTuple Umsetzung? (Kommentar Dinge, bis Sie finden, was eine exakte Linie zu dem Fehler führen)
Ich habe geändert, die Frage, um loszuwerden, steigern, und fügte einen link zu einem live-Beispiel.

InformationsquelleAutor quant | 2014-11-05

  1. 6

    Dies ist das problem, Sie bekommen ein "gelöscht Konstruktor" Fehler:

    std::function<void(A)> f = [](A& a) { a.a++; };

    Sie versuchen, eine std::function übergibt eine A Wert. Aber A wird, kein copy-Konstruktor, kann nicht durch Wert übergeben werden.

    Versuchen Abgleich der tatsächlichen Argumenttyp mehr gezielt:

    std::function<void(A&)> f = [](A& a) { a.a++; };

    Aber da Sie nicht die Erfassung von Variablen, können Sie einfach versuchen

    void(*f)(A&) = [](A& a) { a.a++; };

    Sie haben auch ein großes problem mit der base-case-dein template-Rekursion: auch wenn Sie enable_if arbeiten, scheint es nicht zu sein, Sie haben einen zweideutigen Ruf. Ich glaube, Sie müssen auch deaktivieren die Hauptsache.

    Ich habe es geändert, gleicher Fehler: ideone.com/b8nLCy
    Sieht aus wie der Fehler kommt von der T t(0, 0, 0); Linie. "prog.cpp:41:18: erforderlich von hier", Dennoch, wenn Sie fixiert, dass Sie würde immer noch laufen in das problem, dass Ben Punkte heraus, so wie es aussieht, seine Antwort ist richtig, aber nicht vollständig.
    ja, ich denke, dass die Konstruktor ist die Frage...
    clang ist die Verarbeitung der Bau von t ganz gut, Probleme mit dem base bei den template-Rekursion.
    Ich sehe, so ist es vielleicht nur ein Problem mit dieser bestimmten version von g++. Ich würde spekulieren, dass ein implizit-konvertierte Wert nicht richtig behandelt wird, als rvalue und wollte vorschlagen T t(A(0), A(0), A(0));, diese Theorie zu testen.

    InformationsquelleAutor Ben Voigt

  2. 0

    Beim instanziieren std::function<void(A)> eine Funktion mit einer Signatur unter einem A von Wert instanziiert wird. Zu synthetisieren, diese Funktion definition ein kopieren oder verschieben von A benötigt wird. Da A ist nicht kopierbar, aber nicht beweglich, wie ein Konstruktor existiert nicht.

    Natürlich gibt es auch diese lustige Sache:

    T t();

    welche eine Funktion deklariert Rückkehr eine T von Wert erfordert eine Kopie. Beim Aufruf ForEachTuple(t, f) diese Funktion referenziert und instantiiert. Sie kann ersetzen möchten, diese Erklärung durch eine

    T t;
T t{};

    (in der Antwort oben hatte ich nur sah das erste problem, das ich entdeckt).

    InformationsquelleAutor Dietmar Kühl

Schreibe einen Kommentar