For nested templates, when did `>>` become standard C++ (instead of `> >`)?

I seem to recall, in times of yore, being warned against putting two > characters right next to each other (without a space) when dealing with nested t开发者_如何转开发emplate parameters. I even vaguely remember declaring vectors of vectors of whatever and encountering this compilation error.

But now I find that there is absolutely nothing wrong with compiling the dreaded >>...

My question(s) are thus:

At what point did this convention become an acceptable practice?

Is it part of standard C++?

Was it always part of the standard and the compilers I used (and the professors I had) in college just didn't support it yet?

Maybe these questions are a tad bit historical, but for me it seems that proper historical context makes actual remembering trivial.

Templates closed with nested >> are officially supported by the upcoming standard C++0x (now C++11). Previously you would need the space, or a compiler that went the extra mile for you (and did things not indicated by the standard).

The issue stems from the fact that >> in C is the right-shift operator, which is a single lexical token, which conflicts with the two separate > tokens that would be needed during the parsing stage in a classically-constructed C++ compiler (and only in the case of templates, not when it actually is a right-shift). In other words, the >>, if allowed to close nested templates, is lexically ambiguous, but this can be (and is being) addressed by extra sophistication during parsing (which in modern C++ is really nothing new).

The double angle bracket syntax in templates is still illegal in C++, but some compilers (notably Visual Studio) allow it anyway. In C++0x, which was just ratified and is awaiting publication, this has been corrected.

In short, it is still not legal C++, but will be soon. Sme compilers allow it, but since not all do you should still put the spaces in the angle brackets. In two or three years, you won't need to so this anymore.

Hope this helps!

C++0x. You could take a look at this question of mine for more information.

It was not in the standard (until very recently -- a few days ago).

Why?

One Word: Efficiency.

Disallowing that make the grammar context free. This make the compiler a little bit faster. In the good old days, every bit counts. Now, with the advancement of both algorithm and hardware, nobody want this trouble.