Sure. I remember one. For about a million years, you could declare a naked virtual method with int blah() = NULL; -- perhaps it wasn't /suposed/ to be used like that according to the standard... but it worked, and was used a lot, as it made perfect sense.
Then one day, you recompile it and no, it /needs/ to be ZERO and not NULL sorry.
But it's just one simple to fix example, in plenty of cases, especially as templates (and especially template instantiations) evolved, the whole thing would come crashing on you. For a while trying to compile templated code on MS, CodeWarrior and GCC was pretty much impossible without deploying ruses that made C preprocessor macros tame in comparison.
As you yourself admitted, it was not the standard way of doing things. Ever since the first ISO C++ standard, the syntax was =0. And it was never guaranteed that NULL (which is a macro) expands to just plain 0. So even back when it "just worked" for you, chances were good that it only worked on that one implementation that you had, and would've broken if you tried to use a different compiler.
Judging by your mention of CodeWarrior, this all sounds like war stories from pre-standardization days (and of course it still took a while after ISO C++98 was published, for implementations to actually adopt it).
> And it was never guaranteed that NULL (which is a macro) expands to just plain 0.
True, but is was guaranteed that NULL expands to “an implementation-defined C++ null pointer constant” (C++98 §18.1), where a ‘null pointer constant’ is “an integral constant expression (5.19) rvalue of integer type that evaluates to zero" (C++98 §4.10). So while it didn't have to be just plain (literal) 0, it did have to be a compile-time constant integer 0, which is otherwise just as good unless you're doing macro magic.
(This differed from C (ANSI era), in which a null pointer constant can alternatively have type (void*), and often does.)
The fact that a pure declaration requires a literal single character ‘0’ (rather than 0) is just one sad example of C++'s ad-hoc irregular overloading of things to mean different things.
It may be ad-hoc (although I would argue that "0" in this case is really just a token that's a part of syntax - basically a numerical keyword - so expecting a constant expression is too much). But, in any case, the main point is that it never changed - it was always wrong to use =NULL to denote abstract virtual methods, and there were always implementations that broke that. So it's a strange example of the lack of stability in C++.
Oh, ouch. I never knew about that one. I assume it's an effect of various "#define NULL 0" type things that got stomped by the introduction of nullptr in C++11?
Then one day, you recompile it and no, it /needs/ to be ZERO and not NULL sorry.
But it's just one simple to fix example, in plenty of cases, especially as templates (and especially template instantiations) evolved, the whole thing would come crashing on you. For a while trying to compile templated code on MS, CodeWarrior and GCC was pretty much impossible without deploying ruses that made C preprocessor macros tame in comparison.