Captura Lambda como referência const?

É possível capturar por referência const em uma expressão lambda?

Quero que a tarefa marcada abaixo falhe, por exemplo:

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

Atualização: Como essa é uma pergunta antiga, pode ser bom atualizá-la se houver recursos no C ++ 14 para ajudar nisso. As extensões no C ++ 14 nos permitem capturar um objeto não const por referência const? ( Agosto de 2015 )

const não está na gramática para capturas a partir de n3092:

capture:
  identifier
  & identifier
  this

O texto menciona apenas captura por cópia e captura por referência e não menciona nenhum tipo de constância.

Parece uma supervisão para mim, mas não acompanhei o processo de padronização de muito perto.

No c ++ 14usando static_cast/ const_cast:

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

DEMO

No c ++ 17usando std::as_const:

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

DEMO 2

Eu acho que a parte de captura não deve especificar const, como a captura significa, ela só precisa de uma maneira de acessar a variável de escopo externo.

O especificador é melhor especificado no escopo externo.

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

A função lambda é const (não pode alterar o valor em seu escopo); portanto, quando você captura uma variável por valor, a variável não pode ser alterada, mas a referência não está no escopo lambda.

Acho que se você não estiver usando a variável como parâmetro do functor, deverá usar o nível de acesso da função atual. Se você acha que não deveria, então separe seu lambda dessa função, ela não faz parte dela.

De qualquer forma, você pode facilmente obter o mesmo que deseja usando outra referência 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;
}

Mas é o mesmo que assumir que seu lambda precisa ser isolado da função atual, tornando-o não lambda.

Eu acho que você tem três opções diferentes:

• não use referência const, mas use uma captura de cópia
• ignorar o fato de que é modificável
• use std :: bind para vincular um argumento de uma função binária que tenha uma referência const.

usando uma cópia

A parte interessante sobre lambdas com capturas de cópias é que elas são apenas de leitura e, portanto, fazem exatamente o que você deseja.

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

usando std :: bind

std::bindreduz a aridade de uma função. Observe, no entanto, que isso pode / levará a uma chamada de função indireta através de um ponteiro de função.

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

Existe um caminho mais curto.

Observe que não há e comercial antes de "best_string".

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

Use clang ou aguarde até que esse bug do gcc seja corrigido: bug 70385: A captura do Lambda por referência da referência const falha [ https://gcc.gnu.org/bugzilla/show_bug.cgi?id=70385 ]

O uso de uma const simplesmente faz com que o e comercial do algoritmo defina a string como seu valor original. Em outras palavras, o lambda não se definirá realmente como parâmetro da função, embora o escopo ao redor tenha uma variável extra ... Sem defini-la no entanto, ela não definiria a string como o típico [&, & best_string] (string const s) Portanto , é mais provável que seja melhor deixarmos assim, tentando capturar a referência.