esplicita ritorno Tipo di Lambda

Question

Quando provo e compilare il codice (VS2010) Sto ottenendo il seguente errore: 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; 
    }); 
} 

Come ho fatto a specificare che il lambda ha un tipo di ritorno 'vuoto'. Inoltre, come posso specificare che il lambda ha il tipo di ritorno 'bool'?

UPDATE

I seguenti compila. Qualcuno può dirmi perché questo compila e l'altro no?

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

È possibile specificare in modo esplicito il tipo di ritorno di un lambda utilizzando -> Type dopo l'elenco argomenti:

[]() -> Type { } 

Tuttavia, se un lambda ha una dichiarazione e questa affermazione è una dichiarazione di ritorno (e restituisce un'espressione), il compilatore può dedurre il tipo restituito dal tipo di quella espressione restituita. Hai più istruzioni nel tuo lambda, quindi non deduce il tipo.

Answer 2

Il tipo di ritorno di un lambda può dedurre, ma solo quando v'è esattamente una dichiarazione, e questa affermazione è una dichiarazione return che restituisce un'espressione (una lista di inizializzazione non è espressione, per esempio). Se hai un lambda multi-statement, il tipo di reso è considerato nullo.

Pertanto, si dovrebbe fare questo:

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

Ma in realtà, la tua seconda espressione è molto più leggibile.

Answer 3

È possibile avere più di un economico quando ancora tornare:

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

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