Re: Deprecate the use of plain pointers as standard container iterators
Nicola Musatti wrote:
kuyper@wizard.net wrote:
..
3. The semantics that actually will be executed when your code calls
find(). If these are the semantics that are insufficiently specified,
it implies that you don't know enough about which overload of find()
will be called, to be sure that the semantics of that overload are
acceptable. If that's the case, you need to change the syntax of your
function call to ensure that only overloads that are actually
acceptable will be chosen. For instance, if std::find() provides the
semantics you're looking for, then call it by using std::find() rather
than find().
This is the problem. I claim that knowing about argument dependent
lookup, overload resolution in the presence of function template *and*
the definition of the standard library interface should be enough for
me to know exactly which overload of find() will be called in my code.
The fact that it isn't is a most unfortunate circumstance that should
be removed if at all possible.
Any function with the same name as a standard library template, whose
parameter types can make it compete with that template in overload
resolution for particular values of the template parameters, can cause
exactly the same problem, even in contexts that have nothing to do with
the iterator type of standard containers. Pointers to built-in types
are generic, the name "find" is generic - you're virtually guaranteed
to have overload resolution problems when you define such a function,
and that's the problem you're really demonstrating.
The only thing that the standard guarantees about standard container
iterator types are what operations they support. If you write code
whose correct behavior depends upon anything other than the fact that
those operations are supported, and do behave as specified by the
standard, then it's bad code. Writing code that depends upon the
iterator types not being pointers is just a special case of this
general rule. If plain pointers were prohibited as standard container
iterators, it would just change which special cases cause problems, it
wouldn't avoid them.
For example, prohibiting the use of plain pointers as standard
container iterators won't prevent find(v.begin(), v.end(), 2) from
picking up an alternative definition of find(); it would require a
different alternative definition of find() than the one you gave as an
example, but whatever iterator type an implementation choses for a
given container, a find() can be written which will be selected, over
std::find(), by overload resolution. If you don't want that overload
selected, either don't provide that alternative definition of find(),
or don't leave out the std:: qualifier that forces it to be ignored.
---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:std-c++@ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]