¿Captura lambda como referencia constante?

¿Es posible capturar por referencia constante en una expresión lambda?

Quiero que la tarea marcada a continuación falle, por ejemplo:

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

Actualización: como esta es una pregunta antigua, podría ser bueno actualizarla si hay recursos en C ++ 14 para ayudar con esto. ¿Las extensiones en C ++ 14 nos permiten capturar un objeto no constante con referencia constante? ( Agosto 2015 )

const no está en la gramática para capturas a partir de n3092:

capture:
  identifier
  & identifier
  this

El texto solo menciona la captura por copia y la captura por referencia y no menciona ningún tipo de constancia.

Me parece un descuido, pero no he seguido el proceso de estandarización muy de cerca.

En c ++ 14usando static_cast/ const_cast:

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

MANIFESTACIÓN

En c ++ 17utilizando std::as_const:

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

DEMO 2

Creo que la parte de captura no debería especificar const, ya que la captura significa, solo necesita una forma de acceder a la variable de alcance externo.

El especificador se especifica mejor en el alcance externo.

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

La función lambda es constante (no puede cambiar el valor en su alcance), por lo que cuando captura una variable por valor, la variable no se puede cambiar, pero la referencia no está en el alcance lambda.

Supongo que si no estás usando la variable como parámetro del functor, entonces deberías usar el nivel de acceso de la función actual. Si crees que no deberías, separa tu lambda de esta función, no es parte de ella.

De todos modos, puede lograr fácilmente lo mismo que desea utilizando otra referencia constante:

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

Pero eso es lo mismo que asumir que su lambda tiene que estar aislada de la función actual, convirtiéndola en no lambda.

Creo que tienes tres opciones diferentes:

• no use referencia constante, pero use una captura de copia
• ignorar el hecho de que es modificable
• use std :: bind para vincular un argumento de una función binaria que tiene una referencia constante.

usando una copia

La parte interesante de las lambdas con capturas de copia es que en realidad son de solo lectura y, por lo tanto, hacen exactamente lo que usted desea.

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

usando std :: bind

std::bindReduce la aridad de una función. Sin embargo, tenga en cuenta que esto podría / conducirá a una llamada de función indirecta mediante un puntero de función.

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

Hay un camino más corto.

Tenga en cuenta que no hay ampersand antes de "best_string".

Será del 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

Utilice clang o espere hasta que se solucione este error de gcc: error 70385: falla la captura de Lambda por referencia de referencia constante [ https://gcc.gnu.org/bugzilla/show_bug.cgi?id=70385 ]

El uso de una constante simplemente tendrá el algoritmo ampers y establecerá la cadena en su valor original. En otras palabras, el lambda realmente no se definirá como parámetro de la función, aunque el alcance circundante tendrá una variable adicional ... Sin definirlo sin embargo, no definiría la cadena como la típica [&, & best_string] (cadena const s) Por lo tanto , lo más probable es que sea mejor si la dejamos así, tratando de capturar la referencia.