Is there a standard C++ iterator for C strings?

Question

Sometimes I need to pass a C string to a function using the common C++ iterator range interface [first, last). Is there a standard C++ iterator class for those cases, or a standard way of doing it without having to copy the string or call strlen()?

EDIT: I know I can use a pointer as an iterator, but I would have to know where the string ends, what would require me to call strlen().

EDIT2: While I didn't know if such iterator is standardized, I certainly know it is possible. Responding to the sarcastic answers and comments, this is the stub (incomplete, untested):

class CStringIterator
{
public:
    CStringIterator(char *str=nullptr):
        ptr(str)
    {}

    bool operator==(const CStringIterator& other) const
    {
        if(other.ptr) {
            return ptr == other.ptr;
        } else {
            return !*ptr;
        }
    }

    /* ... operator++ and other iterator stuff */

private:
    char *ptr;
};

EDIT3: Specifically, I am interested in a forward iterator, because I want to avoid to iterate over the sring twice, when I know the algorithm will only have to do it once.

Answer 1

There isn't any explicit iterator class, but regular raw pointers are valid iterators as well. Problem with C-strings, though, is that they do not come with a native end iterator, which makes them unusable in range based for loops – directly at least...

You might like to try the following template, though:

template <typename T>
class Range
{
    T* b;
public:
    class Sentinel
    {
        friend class Range;
        Sentinel() { }
        friend bool operator!=(T* t, Sentinel) { return *t; }

    public:
        Sentinel(Sentinel const& o) { }

    };
    Range(T* begin)
            : b(begin)
    { }
    T* begin() { return b; }
    Sentinel end() { return Sentinel(); }
};

Usage:

for(auto c : Range<char const>("hello world"))
{
    std::cout << c << std::endl;
}

It originally was designed to iterate over null-terminated argv of main, but works with any pointer to null terminated array – which a C-string is as well...

Secret is comparing against the sentinel, which actually does a totally different comparison (current pointer pointing the terminating null (pointer))...

Edit: Pre-C++17 variant:

template <typename T>
class Range
{
    T* b;
public:
    class Wrapper
    {
        friend class Range;
        T* t;
        Wrapper(T* t) : t(t) { }
    public:
        Wrapper(Wrapper const& o) : t(o.t) { }
        Wrapper operator++() { ++t; return *this; }
        bool operator!=(Wrapper const& o) const { return *t; }
        T operator*() { return *t; }
    };
    Range(T* begin)
            : b(begin)
    { }
    Wrapper begin() { return Wrapper(b); }
    Wrapper end() { return Wrapper(nullptr); }
};

Answer 2

Actually, yes - sort of. In c++17.

C++17 introduces std::string_view which can be constructed from a c-style string.

std::string_view is a random access (proxy) container which of course fully supports iterators.

Note that although constructing a string_view from a const char* will theoretically call std::strlen, the compiler is allowed to (and gcc certainly does) elide the call when it knows the length of the string at compile time.

Example:

#include <string_view>
#include <iostream>

template<class Pointer>
struct pointer_span
{
    using iterator = Pointer;

    pointer_span(iterator first, std::size_t size)
    : begin_(first)
    , end_(first + size)
    {
    }

    iterator begin() const { return begin_; }
    iterator end() const { return end_; }

    iterator begin_, end_;
};

int main(int argc, char** argv)
{
    for(auto&& ztr : pointer_span(argv, argc))
    {
        const char* sep = "";
        for (auto ch : std::string_view(ztr))
        {
            std::cout << sep << ch;
            sep = " ";
        }
        std::cout << std::endl;
    }
}

See the example output here

Answer 3

Is there a standard C++ iterator for C strings?

Yes. A pointer is an iterator for an array. C strings are (null terminated) arrays of char. Therefore char* is an iterator for a C string.

... using the common C++ iterator range interface [first, last)

Just like with all other iterators, to have a range, you need to have an end iterator.

If you know or can assume that an array fully contains the string and nothing more, then you can get the iterator range in constant time using std::begin(arr) (std::begin is redundant for C arrays which decay to the pointer anyway, but nice for symmetry) and std::end(arr) - 1. Otherwise you can use pointer arithmetic with offsets within the array.

A little bit of care must be taken to account for the null terminator. One must remember that the full range of the array contains the null terminator of the string. If you want the iterator range to represent the string without the terminator, then subtract one from the end iterator of the array, which explains the subtraction in the previous paragraph.

If you don't have an array, but only a pointer - the begin iterator - you can get the end iterator by advancing the beginning by the length of the string. This advancement is a constant operation, because pointers are random access iterators. If you don't know the length, you can call std::strlen to find out (which isn't a constant operation).

---

Example, std::sort accepts a range of iterators. You can sort a C string like this:

char str[] = "Hello World!";
std::sort(std::begin(str), std::end(str) - 1);
for(char c : "test"); // range-for-loops work as well, but this includes NUL

In the case you don't know the length of the string:

char *str = get_me_some_string();
std::sort(str, str + std::strlen(str));

---

Specifically, I am interested in a forward iterator

A pointer is a random access iterator. All random access iterators are also forward iterators. A pointer meets all of the requirements listed in the linked iterator concept.

Answer 4

It is possible to write such iterator, something like this should work:

struct csforward_iterator : 
    std::iterator<std::bidirectional_iterator_tag, const char, void> {

    csforward_iterator( pointer ptr = nullptr ) : p( ptr ) {}

    csforward_iterator& operator++()  { ++p; return *this; }
    csforward_iterator operator++(int) { auto t = *this; ++p; return t; }

    csforward_iterator& operator--()  { --p; return *this; }
    csforward_iterator operator--(int) { auto t = *this; --p; return t; }

    bool operator==( csforward_iterator o ) { 
        return p == o.p or ( p ? not ( o.p or *p ) : not *o.p ); 
    }
    bool operator!=( csforward_iterator o ) { return not operator==( o ); }

    void swap( csforward_iterator &o ) { std::swap( p, o.p ); }

    reference operator*() const { return *p; }
    pointer operator->() const { return p; }
private:
    pointer p;
};

live example

though unfortunately standard one is not provided and it probably would be template over char type (like std::string ).

Answer 5

I'm afraid not, for last you'll need a pointer to the end of the string for which you'll need to call strlen.

Answer 6

If you have a string literal, you can get the end iterator without using std::strlen. If you have only a char*, you'll have to write your own iterator class or rely on std::strlen to get the end iterator.

Demonstrative code for string literals:

#include <iostream>
#include <utility>

template <typename T, size_t N>
std::pair<T*, T*> array_iterators(T (&a)[N]) { return std::make_pair(&a[0], &a[0]+N); }

int main()
{
   auto iterators = array_iterators("This is a string.");

   // The second of the iterators points one character past the terminating
   // null character. To iterate over the characters of the string, we need to 
   // stop at the terminating null character.

   for ( auto it = iterators.first; it != iterators.second-1; ++it )
   {
      std::cout << *it << std::endl;
   }
}

Answer 7

For ultimate safety and flexibility, you end up wrapping the iterator, and it has to carry some state.

Issues include:

• random access - which can be addressed in a wrapped pointer by limiting its overloads to block random access, or by making it strlen() on need
• multiple iterators - when comparing with each other, not end
• decrementing end - which you could again "fix" by limiting the overloads
• begin() and end() need to be same type - in c++11 and some api calls.
• a non-const iterator could add or remove content

Note that it is "not the iterator's problem" if it is randomly seeked outside the range of the container, and it can legally seek past a string_view.end(). It is also fairly standard that such a broken iterator could not then increment to end() any more.

The most painful of these conditions is that end can be decremented, or subtracted, and dereferenced (usually you can't, but for string it is a null character). This means the end object needs a flag that it is the end, and the address of the start, so that it can find the actual end using strlen() if either of these operations occurs.

Answer 8

Is there a standard C++ iterator class for those cases, or a standard way of doing it without having to copy the string

Iterators are a generalization of pointers. Specifically, they're designed so that pointers are valid iterators.

Note the pointer specializations of std::iterator_traits.

I know I can use a pointer as an iterator, but I would have to know where the string ends

Unless you have some other way to know where the string ends, calling strlen is the best you can do. If there were a magic iterator wrapper, it would also have to call strlen.

Answer 9

Sorry, an iterator is something that is normally obtained from an iterable instance. As char * is a basic type and not a class anymore. How do you think something like .begin() or .end(), can be achieved.

By the way, if you need to iterate a char *p knowing it is nul terminated. you just can do the following.

for( char *p = your_string; *p; ++p ) {
    ...
}

but the thing is that you cannot use iterators as they are defined in C++, because char * is a basic type, has no constructor, has no destructor or methods associated.