Actually, it's very well explained in one of the "Effective C++" series.
IIRC, when calling a function, the compiler first looks at the name and only then will try to match the parameters (and choose the right function if there're multiple ones).
So, in that case, it tries to find a function with the name "func" in the Derivate class.. it finds one. Then, it tries to call it and fails because it has the wrong argument. I.e. It won't look at the Base class since it already found a function with the right name.
TL;DR: First = search by name, Second = Match parameters.
Here I was hoping for a true mind-stretching puzzle to start the day/week, and all I get is a rehash of things every C++ programmer should already know.
Is it something that catches people off guard the first time they experience it? Yes. Does it not "make sense" to those who don't understand how C++ compilers work and (more importantly) why they work that way? Yes.
As another poster said, this is already explained in "Effective C++", as well as "Thinking in C++", and like TFA mentions the spec has it too. Yes, we all know C++ is crufty; that's why they invented Java. But it's powerful and it's flexible, and sometimes it's all we've got, so it's best if you learn to use it properly if you're going to use it.
There's a big difference, though: in C#, you can't accidentally mask a base-class function; you have to do so explicitly. If you fail to tell the compiler whether you're overriding, hiding, or replacing, then it's a compilation error. That's a very different beast than the C++ issues discussed in this article.
That is true, but I still hold that .NET is more complex than C++. With C++, the language made a choice (unfortunately, probably not the best one). With .NET, one can encounter both choices in a single program. "Don't do that" is not suffient here; the two choices might have been made in different third party implementations of a common interface (let's say logger subclass A hides Log(char) in the base class with a Log(int), while subclass B overloads it with a Log(int))
Far-sought? Probably, but still surprisingly complex for a language that tries to be simpler than C++.
FWIW, gcc 4.6.3 has no trouble with this code (or my hand-typed simplified variant). So is it incompliant or just not subject to a bug that affects the spec and (presumably) MSVC?
I do wish c++ had a keyword designating a function as implementing a base-class virtual function, similar to C#'s override. Then this kind of thing wouldn't be necessary.
IIRC, when calling a function, the compiler first looks at the name and only then will try to match the parameters (and choose the right function if there're multiple ones).
So, in that case, it tries to find a function with the name "func" in the Derivate class.. it finds one. Then, it tries to call it and fails because it has the wrong argument. I.e. It won't look at the Base class since it already found a function with the right name.
TL;DR: First = search by name, Second = Match parameters.