Type de retour explicite de Lambda

Question

Lorsque j'essaie de 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 spécifié que le lambda a un type de retour « void ». De plus, comment spécifier que le lambda a le type de retour « bool » ?

METTRE À JOUR

Ce qui suit compile. Quelqu'un peut-il me dire pourquoi cela compile et l'autre 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); }));
}

Answer 1

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

 []() -> Type { }

Cependant, si un lambda a une instruction et que cette instruction est une instruction de retour (et qu'elle renvoie une expression), le compilateur peut déduire le type de retour du type de cette expression retournée. Vous avez plusieurs instructions dans votre lambda, il ne déduit donc pas le type.

Answer 2

Le type de retour d'un lambda (en C++11) peut être déduit, mais seulement lorsqu'il y a exactement une instruction, et cette instruction est une instruction return qui renvoie une expression (une liste d'initialisation n'est pas une expression, par exemple). Si vous avez un lambda à plusieurs instructions, le type de retour est supposé être void.

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.

Answer 3

Vous pouvez avoir plus d'une instruction lorsque vous retournez toujours :

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

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