What does the phrase std::string::npos
mean in the following snippet of code?
found = str.find(str2);
if (found != std::string::npos)
std::cout << "first 'needle' found at: " << int(found) << std::endl;
This question is related to
c++
stdstring
c++-standard-library
Value of string::npos is 18446744073709551615. Its a value returned if there is no string found.
we have to use string::size_type
for the return type of the find function otherwise the comparison with string::npos
might not work.
size_type
, which is defined by the allocator of the string, must be an unsigned
integral type. The default allocator, allocator, uses type size_t
as size_type
. Because -1
is
converted into an unsigned integral type, npos is the maximum unsigned value of its type. However,
the exact value depends on the exact definition of type size_type
. Unfortunately, these maximum
values differ. In fact, (unsigned long)-1
differs from (unsigned short)-
1 if the size of the
types differs. Thus, the comparison
idx == std::string::npos
might yield false if idx has the value -1
and idx and string::npos
have different types:
std::string s;
...
int idx = s.find("not found"); // assume it returns npos
if (idx == std::string::npos) { // ERROR: comparison might not work
...
}
One way to avoid this error is to check whether the search fails directly:
if (s.find("hi") == std::string::npos) {
...
}
However, often you need the index of the matching character position. Thus, another simple solution is to define your own signed value for npos:
const int NPOS = -1;
Now the comparison looks a bit different and even more convenient:
if (idx == NPOS) { // works almost always
...
}
An answer for these days of C++17, when we have std::optional
:
If you squint a bit and pretend std::string::find()
returns an std::optional<std::string::size_type>
(which it sort of should...) - then the condition becomes:
auto position = str.find(str2);
if ( position.has_value() ) {
std::cout << "first 'needle' found at: " << found.value() << std::endl;
}
std::string::npos
is implementation defined index that is always out of bounds of any std::string
instance. Various std::string
functions return it or accept it to signal beyond the end of the string situation. It is usually of some unsigned integer type and its value is usually std::numeric_limits<std::string::size_type>::max ()
which is (thanks to the standard integer promotions) usually comparable to -1
.
found
will be npos
in case of failure to find the substring in the search string.
string::npos
is a constant (probably -1
) representing a non-position. It's returned by method find
when the pattern was not found.
The document for string::npos
says:
npos is a static member constant value with the greatest possible value for an element of type size_t.
As a return value it is usually used to indicate failure.
This constant is actually defined with a value of -1 (for any trait), which because size_t is an unsigned integral type, becomes the largest possible representable value for this type.
size_t
is an unsigned variable, thus 'unsigned value = - 1' automatically makes it the largest possible value for size_t
: 18446744073709551615
npos is just a token value that tells you that find() did not find anything (probably -1 or something like that). find() checks for the first occurence of the parameter, and returns the index at which the parameter begins. For Example,
string name = "asad.txt";
int i = name.find(".txt");
//i holds the value 4 now, that's the index at which ".txt" starts
if (i==string::npos) //if ".txt" was NOT found - in this case it was, so this condition is false
name.append(".txt");
$21.4 - "static const size_type npos = -1;"
It is returned by string functions indicating error/not found etc.
static const size_t npos = -1;
Maximum value for size_t
npos is a static member constant value with the greatest possible value for an element of type size_t.
This value, when used as the value for a len (or sublen) parameter in string's member functions, means "until the end of the string".
As a return value, it is usually used to indicate no matches.
This constant is defined with a value of -1, which because size_t is an unsigned integral type, it is the largest possible representable value for this type.
Source: Stackoverflow.com