Cattura lambda come riferimento const?

È possibile catturare per riferimento const in un'espressione lambda?

Voglio che il compito indicato di seguito fallisca, ad esempio:

#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;
}

Aggiornamento: poiché questa è una vecchia domanda, potrebbe essere utile aggiornarla se ci sono delle funzionalità in C ++ 14 per aiutarlo. Le estensioni in C ++ 14 ci consentono di catturare un oggetto non const per riferimento const? ( Agosto 2015 )

const non è nella grammatica per le acquisizioni a partire da n3092:

capture:
  identifier
  & identifier
  this

Il testo menziona solo l'acquisizione per copia e l'acquisizione per riferimento e non menziona alcun tipo di costanza.

Mi sembra una svista, ma non ho seguito da vicino il processo di standardizzazione.

Nel c ++ 14usando static_cast/ const_cast:

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

DEMO

Nel c ++ 17utilizzando std::as_const:

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

DEMO 2

Penso che la parte di acquisizione non debba specificare const, poiché la cattura significa, ha solo bisogno di un modo per accedere alla variabile dell'ambito esterno.

Lo specificatore è meglio specificato nell'ambito esterno.

const string better_string = "XXX";
[&better_string](string s) {
    better_string = s;    // error: read-only area.
}

La funzione lambda è const (non è possibile modificare il valore nel suo ambito), quindi quando si acquisisce una variabile in base al valore, la variabile non può essere modificata, ma il riferimento non si trova nell'ambito di lambda.

Immagino che se non stai usando la variabile come parametro del functor, allora dovresti usare il livello di accesso della funzione corrente. Se pensi che non dovresti, allora separa la tua lambda da questa funzione, non fa parte di essa.

Ad ogni modo, puoi facilmente ottenere la stessa cosa che desideri utilizzando invece un altro riferimento const:

#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;
}

Ma è lo stesso che supporre che il tuo lambda debba essere isolato dalla funzione corrente, rendendolo un non-lambda.

Penso che tu abbia tre diverse opzioni:

• non usare il riferimento const, ma usa una cattura della copia
• ignora il fatto che è modificabile
• usa std :: bind per associare un argomento di una funzione binaria che ha un riferimento const.

usando una copia

La parte interessante di lambdas con le acquisizioni di copie è che queste sono effettivamente di sola lettura e quindi fanno esattamente quello che vuoi che facciano.

int main() {
  int a = 5;
  [a](){ a = 7; }(); // Compiler error!
}

usando std :: bind

std::bindriduce l'arità di una funzione. Si noti tuttavia che ciò potrebbe / porterà a una chiamata di funzione indiretta tramite un puntatore a funzione.

int main() {
  int a = 5;
  std::function<int ()> f2 = std::bind( [](const int &a){return a;}, a);
}

C'è un modo più breve.

Si noti che non esiste una e commerciale prima di "best_string".

Sarà di tipo "const std :: reference_wrapper << T >>".

[best_string = cref(best_string)](const string& s)
{
    best_string = s; // fails
};

http://coliru.stacked-crooked.com/a/0e54d6f9441e6867

Usa clang o aspetta fino a quando questo bug gcc è stato risolto: bug 70385: acquisizione lambda per riferimento del riferimento const non riuscita [ https://gcc.gnu.org/bugzilla/show_bug.cgi?id=70385 ]

L'uso di una const farà semplicemente in modo che l'algoritmo e commerciale imposti la stringa sul suo valore originale, in altre parole, la lambda non si definirà realmente come parametro della funzione, anche se l'ambito circostante avrà una variabile extra ... Senza definirla tuttavia, non definirebbe la stringa come la tipica [&, & best_string] (string const s) Pertanto , è molto meglio se la lasciamo, cercando di catturare il riferimento.