Re: Bjarne's member function binding sample is wrong?
* George:
Here is the quoted section, words from Bjarne and his sample.
Please also state which book or article.
One might suspect "The C++ Programming Language" 3rd edition, but it could be
any of Bjarne's books, really.
The reason why
I think the sample is wrong, is because, the member function sort accepts
empty arguments, so when we call ::sort (v), only the one in global namespace
will be matched -- there is no ambiguity to call sort member function of
Container from parameter list comparison. I do not know why Bjarne commets
"sort (vector<T>&) which calls std::sort() rather than Container::sort()" --
I think it has nothing to do with template -- just a normal function call
matching.
Any comments? Do you agree with me and think his sample is wrong?
section 13.8.3 Point of Instantiation Binding
--------------------
unqualified name can not be bound to members of that class
I do not quite understand this comment or heading, whatever it is. Perhaps
Bjarne (if this is a quote from whatever book or article you're referring to) is
describing an apparent problem from the point of view of the programmer, rather
than making a statement. As an out-of-context general statement it's wrong.
[Code]
template <class T> void sort (vector<T>& v)
{
sort (v.begin(), v.end());
}
class Container {
vector<int> v; // elements
public:
void sort() // sort elements
{
::sort (v); // sort (vector<T>&) which calls std::sort() rather than
Container::sort()
}
};
[/Code]
Consider
<code>
#include <vector>
#include <algorithm>
using namespace std;
void sort( vector<int>& v ) { sort( v.begin(), v.end() ); }
class Container
{
vector<int> v;
public:
void sort()
{
sort( v ); // Ungood.
}
};
int main()
{
Container c;
c.sort();
}
</code>
Name lookup stops when "sort" is found as a member function[1]. At this point
the argument has only influenced the lookup by bringing in the associated
namespace "std" as a possible place to look for the name. However, namespace
"std" is not searched, because "sort" is found as a class member function.
The template thing is just a red herring, but I suspect it followed from some
original problem that led to the quoted discussion.
Since the member function signature doesn't match the call, the result is a
compilation error (note: the standard doesn't prescribe the form of the
diagnostic, so theoretically the compiler could just emit a warning).
Cheers, & hth.,
- Alf
Notes:
[1] ?3.4.2/2 about lookup of an unqualified function call's function name: "If
the ordinary unqualified lookup of the name finds the declaration of a class
member function, the associated namespaces and classes are not considered." This
means that a member function is always the best match. Regardless of args.
--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?