En C ++ 11, ¿cuándo se supone que las variables ligadas de una expresión lambda se capturan por valor?

Tengo un programa Visual Studio 2010 C ++, cuya función principal es:

vector<double> v(10);

double start = 0.0; double increment = 10.0;
auto f = [&start, increment]() { return start += increment; };
generate(v.begin(), v.end(), f);
for(auto it = v.cbegin(); it != v.cend(); ++it) { cout << *it << ", "; }

cout << endl << "Changing vars to try again..." << endl;
start = 15; i,ncrement = -1.5;
generate(v.begin(), v.end(), f);
for(auto it = v.cbegin(); it != v.cend(); ++it) { cout << *it << ", "; }
return 0;

Cuando compilo esto en MS Visual Studio, la primera generación hace lo que esperaba, dando como resultado "10, 20, ... 100". El segundo no; la lambda "ve" el cambio enstart pero no el cambio enincrement, así que obtengo "25, 35, ... 115".

MSDN explica es

El compilador de Visual C ++ vincula una expresión lambda a sus variables capturadas cuando se declara la expresión en lugar de cuando se llama a la expresión. ... [L] a reasignación de [una variable capturada por valor] más adelante en el programa no afecta el resultado de la expresión.

Así que mi pregunta es: ¿es este comportamiento C ++ 11 compatible con los estándares, o es la propia implementación excéntrica de Microsoft? Bono: si ese comportamiento estándar, ¿por qué se escribió el estándar de esa manera? ¿Tiene que ver con hacer cumplir la transparencia referencial para la programación funcional?