Explicite le Type de Retour de la Lambda

Quand j'essaie de le compiler ce code (VS2010) j'obtiens l'erreur suivante:
error C3499: a lambda that has been specified to have a void return type cannot return a value

void DataFile::removeComments()
{
  string::const_iterator start, end;
  boost::regex expression("^\\s?#");
  boost::match_results<std::string::const_iterator> what;
  boost::match_flag_type flags = boost::match_default;
  //Look for lines that either start with a hash (#)
  //or have nothing but white-space preceeding the hash symbol
  remove_if(rawLines.begin(), rawLines.end(), [&expression, &start, &end, &what, &flags](const string& line)
  {
    start = line.begin();
    end = line.end();
    bool temp = boost::regex_search(start, end, what, expression, flags);
    return temp;
  });
}

Comment ai-je préciser que le lambda a un "vide" type de retour. De plus, comment puis-je spécifier que le lambda a 'bool' type de retour?

Mise à JOUR

La suivante compile. Quelqu'un peut-il me dire pourquoi qui compile et l'autre ne l'est pas?

void DataFile::removeComments()
{
  boost::regex expression("^(\\s+)?#");
  boost::match_results<std::string::const_iterator> what;
  boost::match_flag_type flags = boost::match_default;
  //Look for lines that either start with a hash (#)
  //or have nothing but white-space preceeding the hash symbol
  rawLines.erase(remove_if(rawLines.begin(), rawLines.end(), [&expression, &what, &flags](const string& line)
  { return boost::regex_search(line.begin(), line.end(), what, expression, flags); }));
}
  • Vous pouvez le spécifier explicitement avec ->, par exemple [&](double d) -> double { //...
  • Je vous conseille seulement implicitement, capture les variables dont vous avez besoin (seulement [&]...), comme ce que vous avez actuellement est inutilement verbeux.
  • pouvez-vous me dire pourquoi sa verbose? J'ai besoin de ce que, d'expression et de drapeaux dans le lambda et c'est ce que j'ai capturé. Quel manière plus pourrais-je couper?
  • [&expression, &start, &end, &what, &flags]... (la vôtre) vs [&]... (le mien). Maintenant, dites-moi qui est plus détaillé. 😉 [&] dit le lambda à capturer tout ce que vous utilisez à l'intérieur du corps de lambda, par référence. Il a appelé à une "capture par défaut". L'autre est [=] et la capture par copie.
  • Moderne et efficace de C++, Point 31, recommande la capture explicitement, pour éviter de pendre des références. J'ai été mordu par le fait que quelques fois moi-même en tant que punition pour être laz... er, concis. 🙂
  • Que uniquement les questions pour les lambdas survivre à la portée actuelle dans une forme ou une autre, vraiment, qui n'est certainement pas le cas ici.
  • bon point!
  • Par ailleurs, les contraintes sont réduites à déduire de retour de lambdas en C++14. Les types de retour peuvent être déduits pour les lambdas avec plus d'une instruction dans le corps, et aussi longtemps que l'expression de chaque instruction return est du même type, vous pouvez maintenant avoir une déduit le type de retour avec plusieurs instructions return.
  • Voir aussi Est mon livre de la discussion de lamba types de retour de mal?, Quand peut-on omettre le type de retour dans un C++11 lambda?, Pourquoi ne lambda fonctions chute de déduire le type de retour de référence par défaut? et Explicite le Type de Retour de la Lambda.

InformationsquelleAutor Ryan | 2012-03-08
  1. 159

    Vous pouvez spécifier explicitement le type de retour d'une lambda en utilisant -> Type après les arguments de la liste:

    []() -> Type { }

    Toutefois, si un lambda a un énoncé et que l'instruction est une instruction de retour (et il retourne une expression), le compilateur peut en déduire le type de retour et le type de qui on est rentré expression. Vous avez plusieurs instructions dans votre lambda, afin de ne pas déduire le type.

    • le compilateur peut le faire, mais la norme interdit de le faire.
    • -1: Ce n'est pas un bug du compilateur. La norme est très clair sur ce point: la section 5.1.2, paragraphe 4 stipule la manière dont la déduction est faite et dans quelles conditions.
    • fixe.
    • Alors qu'il n'est pas permis selon le dernier projet que j'ai pu trouver, on dirait qu'il est effectivement permis dans les spécifications finales de passer par les commentaires pour ce patch gcc.gnu.org/ml/gcc-patches/2011-08/msg01901.html. Toute personne a le dernier spec pour vérifier?
    • J'ai utilisé les expressions lambda largement et pas une seule fois ai-je déclarer explicitement le type de retour. La déduction du type de retour (au moins sous VS2012 & VS2013) fonctionne parfaitement même si il n'y a plus d'une instruction de retour dans l'expression lambda. Bien sûr, les différents retour déclarations doivent correspondre à l'intérieur de la même expression lambda. E. g. un énoncé tel que "auto f = [](int i) { if(i > 5) return true; return false; };" compile sans problème et si vous appelez "auto b = f(10);" b " est de type bool et bien sûr être vrai;
    • return nullptr; peut jeter une clé dans le type de déduction, même si c'est valide que n'importe quel type de pointeur est autrement retourné.
    • return ptr; on peut également jeter une clé dans le type de déduction si const est impliqué.

    InformationsquelleAutor Seth Carnegie
  2. 11

    Le type de retour d'une lambda (en C++11) peut être déduit, mais seulement quand il y a exactement une seule instruction, et cette déclaration est un return énoncé qui renvoie à une expression (un initialiseur liste n'est pas une expression, par exemple). Si vous avez un multi-déclaration lambda, puis le type de retour est supposé nul.

    Par conséquent, vous devriez faire ceci:

      remove_if(rawLines.begin(), rawLines.end(), [&expression, &start, &end, &what, &flags](const string& line) -> bool
  {
    start = line.begin();
    end = line.end();
    bool temp = boost::regex_search(start, end, what, expression, flags);
    return temp;
  })

    Mais vraiment, votre deuxième expression est beaucoup plus lisible.

    • Bel exemple; pinaille: votre appel de fonction manquant ); à la fin?
    InformationsquelleAutor Nicol Bolas
  3. 5

    Vous pouvez avoir plus qu'une seule déclaration lorsqu'elles sont encore de retour:

    []() -> your_type {return (
        your_statement,
        even_more_statement = just_add_comma,
        return_value);}

    http://www.cplusplus.com/doc/tutorial/operators/#comma

    • virgule est une révolte de l'opérateur. sa brouille les gens qui ne sont pas au courant de son existence ou de niveau de priorité. il n'y a jamais une utilisation valide, soit de l'omi. il peut toujours être évité avec plus de fonctions ou autrement mieux organisés code.
    • d'accord, l'existence de ma réponse n'est que pour ceux qui veulent vraiment un indépendant one-liner solution XD (c'est toujours une ligne, droite?). La virgule n'est pas vraiment perceptible, et ne serait jamais mettre l'ensemble de la méthode main dans ce formulaire.
    • bien sûr, vous n'êtes certainement donner une réponse valable, je ne suis pas un fan de jamais rien faire pour encourager ou même de démontrer la mauvaise pratique. une fois que les gens apprennent que la virgule est un opérateur de son un compte à rebours jusqu'à ce qu'ils commencent à en abuser et un plus long jusqu'à ce qu'ils apprennent mieux. 🙂
    • Je l'ai vu mettre pour une utilisation intéressante dans un membre de l'initialisation de la liste une fois, mais c'était juste pour déconner, si je me souviens bien.
    InformationsquelleAutor Valen