tab-completion (or "intellisense") requires something very similar to a parse in order to figure out what reasonable completions/follows might be. You probably have some experience with that in some IDE. If so, you will also have noticed some of its limitations.
Systems like SO's preview feature periodically parse the input, but not necessarily on every keystroke. You might notice that syntax highlighting lags a bit, particularly when the buffer is full. A typical strategy is to have a single process which repeatedly reparses until the input hasn't changed during the parse, and then waits for the next change.
Text editors like vim and emacs do reparse on every keystroke but they optimize by caching context at line endings (usually), so that the reparse is only on a few characters. (Of course, they don't do a full parse, so its even easier.)
There has been some research into incremental parsing and in-place editing of abstract syntax trees, but it turns to be quite tricky. One parsing strategy which lends itself naturally to this style is "packrat parsing" (an extensive bibliography is available here).
C++ is notoriously difficult to parse correctly. Indeed, it's non-trivial to figure out whether a given <
is a template-bracket or a less-than sign; in general, you can't do that without reading all header files, and in some cases you can't figure it out without instantiating templates; that's far too much work to do interactively. Many other languages are easier to parse, and the simple solution of reparsing periodically will be fast enough for all practical purposes.
Hope that hits most of your questions.