Type de retour explicite de Lambda

Lorsque j'essaye 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 un type de retour 'bool'?

METTRE À JOUR

Les compilations suivantes. Quelqu'un peut-il s'il vous plaît 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); }));
}

Vous pouvez spécifier explicitement le type de retour d'un lambda en utilisant -> Typeaprès la liste d'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, donc il ne déduit pas le type.

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 returninstruction qui renvoie une expression (une liste d'initialiseurs 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 devez 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.

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/#comma