Capture Lambda comme référence const?

Est-il possible de capturer par référence const dans une expression lambda?

Je souhaite que le devoir indiqué ci-dessous échoue, par exemple:

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

Mise à jour: Comme il s'agit d'une vieille question, il pourrait être bon de la mettre à jour s'il existe des fonctionnalités dans C ++ 14 pour vous aider. Les extensions en C ++ 14 nous permettent-elles de capturer un objet non const par référence const? ( Août 2015 )

const n'est pas dans la grammaire des captures à partir de n3092:

capture:
  identifier
  & identifier
  this

Le texte ne mentionne que la capture par copie et la capture par référence et ne mentionne aucune sorte de const-ness.

Cela me semble un oubli, mais je n'ai pas suivi de très près le processus de normalisation.

Dans c ++ 14en utilisant static_cast/ const_cast:

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

DEMO

Dans c ++ 17utilisant std::as_const:

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

DÉMO 2

Je pense que la partie de capture ne devrait pas spécifier const, comme moyen de capture, il suffit d'un moyen d'accéder à la variable de portée externe.

Le spécificateur est mieux spécifié dans la portée externe.

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

La fonction lambda est const (ne peut pas changer la valeur dans sa portée), donc lorsque vous capturez une variable par valeur, la variable ne peut pas être modifiée, mais la référence n'est pas dans la portée lambda.

Je suppose que si vous n'utilisez pas la variable comme paramètre du foncteur, vous devriez utiliser le niveau d'accès de la fonction actuelle. Si vous pensez que vous ne devriez pas, alors séparez votre lambda de cette fonction, cela n'en fait pas partie.

Quoi qu'il en soit, vous pouvez facilement obtenir la même chose que vous voulez en utilisant une autre référence const à la place:

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

Mais c'est la même chose que de supposer que votre lambda doit être isolé de la fonction actuelle, ce qui en fait un non-lambda.

Je pense que vous avez trois options différentes:

• n'utilisez pas de référence const, mais utilisez une capture de copie
• ignorer le fait qu'il est modifiable
• utilisez std :: bind pour lier un argument d'une fonction binaire qui a une référence const.

en utilisant une copie

La partie intéressante à propos des lambdas avec des captures de copie est que celles-ci sont en réalité en lecture seule et font donc exactement ce que vous voulez.

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

en utilisant std :: bind

std::bindréduit l'arité d'une fonction. Notez cependant que cela pourrait / conduira à un appel de fonction indirect via un pointeur de fonction.

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

Il existe un moyen plus court.

Notez qu'il n'y a pas d'esperluette avant "best_string".

Il sera de type "const std :: reference_wrapper << T >>".

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

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

Utilisez clang ou attendez que ce bogue gcc soit corrigé: bogue 70385: La capture Lambda par référence à la référence const échoue [ https://gcc.gnu.org/bugzilla/show_bug.cgi?id=70385 ]

L'utilisation d'un const aura simplement l'esperluette de l'algorithme et définira la chaîne sur sa valeur d'origine.En d'autres termes, le lambda ne se définira pas vraiment comme paramètre de la fonction, bien que la portée environnante aura une variable supplémentaire ... Sans la définir cependant, cela ne définirait pas la chaîne comme la chaîne typique [&, & best_string] (string const s). Par conséquent , il est plus probable que nous nous en tenions à cela, essayant de capturer la référence.