Why does s.find return string::npos instead of s.length() on failure [closed]

Question

I recently was annoyed to find that string::find returns string::npos when the needle isn't found in the haystack. This makes the following seemingly-elegant code compile but throw an out-of-range exception:

s.erase(s.find('#')); // erase everything after a # if one exists

If find returned s.length() on failure, it would work fine. Instead you have to do

auto pos = s.find('#');
if (pos != s.npos)
    s.erase(pos);

This is also inconsistent with std::find which returns the end iterator if the item isn't found.

I know the standard people are pretty smart so I believe they didn't just come up with this out of nowhere. It must give some elegance somewhere else that I'm not seeing. What is the good reason for this?

Answer 1

Your question is actually twofold:

1) Why does std::string have it's own find function that returns a std::size_t value instead of an iterator?

This is largely due to the fact that std::string was developed separately from much of the rest of the standard library. It is only in recent standards that it has been embraced by other templates (e.g. iostream). So when it was added to the standard, it had some functions added to it, but it's orginal functionality was left pretty much as-is (the exception being the common implemention of copy-on-write, which was forbidden in the C++11 standard). It was left this way largely for backward-compatibility.

Per your question about why it was that way to begin with: The original string.h was a very thin wrapper around several C string functions. It was not at all uncommon to see strlen used as a return value for length(), or strcpy used in the copy constructor. There was no requirement forcing the use of these functions, so eventually implementers started doing some interesting things (e.g. copy-on-write, non-contiguous memory blocks), but they left the interface the same to preserve backwards-compatibility. While functions have been added to it, no public functions have been removed from the interface. So you can trace the design decisions for using a pointer and length for function parameters back to the days when it was merely a wrapper around the C functions.

2) How can you write an erase sequence on a string without having to check the return value?

This can be done simply by using the find-erase idiom, but not using std::string's find function:

s.erase(std::find(s.begin(), s.end(), '#'), s.end());

Answer 2

Using std::string::npos makes the result a constant expression unlike std::string::length(). Since npos isn't suitable as an iterator anyway there is value in having a constant expression, e.g., it can be used as default for parameters taking a std::string::size_type.

Another reason is that the basic interface for std::basic_string was put together before STL was added to the C++ standard library (well, at least, there is a part of the interface which existed then). The original interface was basically an immutable string and I think it didn't support any mutation of the string itself.