Lambda-Capture als konstante Referenz?

Ist es möglich zu erfassen, die von const-Referenz in einem lambda-Ausdruck?

Möchte ich die Zuordnung markiert unten, um zu scheitern, zum Beispiel:

#include <cstdlib>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

int main()
{
    string strings[] = 
    {
        "hello",
        "world"
    };
    static const size_t num_strings = sizeof(strings)/sizeof(strings[0]);

    string best_string = "foo";

    for_each( &strings[0], &strings[num_strings], [&best_string](const string& s)
      {
        best_string = s; //this should fail
      }
    );
    return 0;
}

Update: dies ist eine alte Frage, es könnte gut sein, um es zu aktualisieren, wenn es Einrichtungen gibt, die in C++14 zu helfen. Tun die Erweiterungen in C++14 erlauben uns zu erfassen, eine nicht-const-Objekt const-Referenz? (August 2015)

InformationsquelleAutor der Frage John Dibling | 2010-09-22

c++c++11 c++14 lambda

95

const ist nicht in der Grammatik erfasst, wie der n3092:
```
capture:
  identifier
  & identifier
  this
```
Den text nur erwähnen, erfassen von Kopie-und capture-by-reference und erwähnt nicht, dass jede Art von const-ness.

Fühlt sich an wie aus versehen zu mir, aber ich habe nicht gefolgt, die Standardisierung des Prozesses sehr eng.

InformationsquelleAutor der Antwort Steve M

C++14:

[&best_string = static_cast<const std::string&>(best_string)](const string& s)
{
    best_string = s; //fails
};

DEMO

C++17:

[&best_string = std::as_const(best_string)](const string& s)
{
    best_string = s; //fails
};

DEMO 2

InformationsquelleAutor der Antwort Piotr Skotnicki

12

Ich denke, dass die capture-Teil sollte nicht angeben constwie die capture-bedeutet, dass es nur einen Weg brauchen, um Zugriff auf den äußeren scope variable.

Die Planer besser ist angegeben in den äußeren Umfang.
```
const string better_string = "XXX";
[&better_string](string s) {
    better_string = s;    //error: read-only area.
}
```
lambda-Funktion ist const(kann nicht geändert Wert im Bereich), so dass, wenn Sie die capture-variable der Wert der variable kann nicht geändert werden, aber die Referenz ist nicht in der lambda-Bereich.

InformationsquelleAutor der Antwort zhb

Ich denke, wenn du nicht mit der variable als parameter des funktors, dann sollten Sie den Zugang Stufe der aktuellen Funktion. Wenn Sie denken, dass Sie sollten nicht, dann trennen sich Ihre lambda-von dieser Funktion, es ist nicht Teil davon.

Sowieso, Sie kann leicht erreichen Sie die gleiche Sache, die Sie wollen, indem Sie anderen const-Referenz statt :

#include <cstdlib>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

int main()
{
    string strings[] = 
    {
        "hello",
        "world"
    };
    static const size_t num_strings = sizeof(strings)/sizeof(strings[0]);

    string best_string = "foo";
    const string& string_processed = best_string;

    for_each( &strings[0], &strings[num_strings], [&string_processed]  (const string& s)  -> void 
    {
        string_processed = s;    //this should fail
    }
    );
    return 0;
}

Aber das ist das gleiche wie unter der Annahme, dass deine lambda haben, isoliert zu sein, von der aktuellen Funktion, sodass es ein non-lambda.

InformationsquelleAutor der Antwort Klaim

5

Denke ich, haben Sie drei verschiedene Möglichkeiten:
- nicht verwenden, const Referenz, sondern eine Kopie capture
- die Tatsache ignorieren, dass es änderbar ist
- verwenden std::bind zu binden, ein argument einer binären Funktion, die eine const-Referenz.
mit einer Kopie

Der interessante Teil über Lambda-Ausdrücke mit kopieren erfasst ist, dass diese eigentlich nur Lesen und somit genau das tun, was Sie wollen.
```
int main() {
  int a = 5;
  [a](){ a = 7; }(); //Compiler error!
}
```
mit std::bind

std::bind reduziert die stelligkeit einer Funktion. Beachten Sie jedoch, dass das könnte/wird führen zu ein Indirekter Funktionsaufruf über Funktionszeiger.
```
int main() {
  int a = 5;
  std::function<int ()> f2 = std::bind( [](const int &a){return a;}, a);
}
```
InformationsquelleAutor der Antwort Alex
3

Gibt es einen kürzeren Weg.

Beachten Sie, dass kein kaufmännisches und-Zeichen vor "best_string".

Wird es eine "const std::reference_wrapper<< T >>" Typ.
```
[best_string = cref(best_string)](const string& s)
{
    best_string = s; //fails
};
```
http://coliru.stacked-crooked.com/a/0e54d6f9441e6867

InformationsquelleAutor der Antwort Sergey Palitsin
0

Verwenden clang oder warten Sie, bis der gcc-bug ist behoben:
bug 70385: Lambda-capture mit Verweis auf const-Referenz fehlschlägt [https://gcc.gnu.org/bugzilla/show_bug.cgi?id=70385]

InformationsquelleAutor der Antwort user1448926
0

Verwendung einer const wird einfach der Algorithmus kaufmännische und legen Sie die Zeichenfolge auf den ursprünglichen Wert,
In anderen Worten, die lambda nicht wirklich definieren sich selbst als parameter an die Funktion, wenn der umliegende Bereich wird eine zusätzliche variable...
Ohne es zu definieren, obwohl, wäre es nicht definieren Sie die Zeichenfolge, die als typisch
[&, &best_string](const string s)
Daherseine wahrscheinlich besser, wenn wir Sie nur lassen Sie es auf und versuchte zu erfassen, die Referenz.

InformationsquelleAutor der Antwort Saith

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

mit einer Kopie

mit std::bind