Explizite Rückgabe Typ von Lambda

Wenn ich versuche, diesen Code (VS2010) zu kompilieren, wird folgende Fehlermeldung angezeigt: 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;
  });
}

Wie habe ich angegeben, dass das Lambda einen Rückgabetyp "void" hat? Wie kann ich außerdem angeben, dass das Lambda den Rückgabetyp 'bool' hat?

AKTUALISIEREN

Das Folgende wird kompiliert. Kann mir bitte jemand sagen, warum das kompiliert und der andere nicht?

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

Sie können den Rückgabetyp eines Lambda explizit angeben, indem Sie -> Typenach der Argumentliste Folgendes verwenden:

[]() -> Type { }

Wenn ein Lambda jedoch eine Anweisung hat und diese Anweisung eine return-Anweisung ist (und einen Ausdruck zurückgibt), kann der Compiler den Rückgabetyp aus dem Typ dieses einen zurückgegebenen Ausdrucks ableiten. Sie haben mehrere Anweisungen in Ihrem Lambda, daher wird der Typ nicht abgeleitet.

Der Rückgabetyp eines Lambda (in C ++ 11) kann abgeleitet werden, jedoch nur, wenn genau eine Anweisung vorhanden ist und diese Anweisung eine returnAnweisung ist, die einen Ausdruck zurückgibt (eine Initialisierungsliste ist beispielsweise kein Ausdruck). Wenn Sie ein Lambda mit mehreren Anweisungen haben, wird angenommen, dass der Rückgabetyp ungültig ist.

Deshalb sollten Sie Folgendes tun:

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

Aber wirklich, Ihr zweiter Ausdruck ist viel besser lesbar.

Sie können mehr als eine Anweisung haben, wenn Sie noch zurückkehren:

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

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