Iterate over NULL terminated array of strings using for_each

Question

Iterating over a NULL terminated string using for_each is possible:

const char *name = "Bob";

void func(const char &arg)
{
   cout << arg;
}

int main()
{
    for_each(name, name + strlen(name), func);
}

Is something similar possible for a NULL terminated list of strings (without having to determine the total length of the list first) such as:

const char *names[] = { "Bob", "Adam", "Simon", NULL };

Answer 1

With

const char *names[] = { "Bob", "Adam", "Simon" };

you can just call

std::for_each(names, names + sizeof(names)/sizeof(names[0]), func );

or, nicer, using two helper functions:

std::for_each(begin(names), end(names), func );

Of course, this fails the moment the array decays into a pointer (but at least the compiler won't accept it then). If you must rely on that trailing NULL, you either need to write your own looping function or count before-hand, as with std::strlen():

std::ptr_diff_t num = std::find( names
                               , names + std::numeric_limits<std::size_t>::max()
                               , NULL);
std::for_Each( names, names+num, func );

Answer 2

You can use sizeof() for compile-time sized arrays.

const char *names[] = { "Bob", "Adam", "Simon" };
std::for_each(names, names + sizeof(names)/sizeof(*names), [](const char* arg) {
    std::cout << arg << "\n";
});
std::cin.get();

For dynamically sized arrays, you should be using std::vector<std::string> and iterate over that.

Excuse my use of lambdas, your compiler (probably) doesn't support them.

Answer 3

add them to a container instead, and iterate over them using for_each
i use a vector for my example:

void function(string name)
{
    cout << name;
}

int main()
{
    vector<string> nameVector;

    nameVector.push_back("Bob");
    nameVector.push_back("Adam");
    nameVector.push_back("Simon");

    for_each(nameVector.begin(), nameVector.end(), function);

    return 0;
}

Answer 4

std::for_each "iterates" over a range, so to use it with an array of indeterminate length, you need to use custom iterators to signal the end of the array (on NULL member). If you insist on using NULL-terminated char* array, you could of course create your own for_each function for it, for example like this:

template <typename Function>
void for_each_in_null_terminated_cstring_array(const char** array, Function f)
{
    while (*array) {
        f(*array);
        array++;
    }
}

const char *names[] = { "Bob", "Adam", "Simon", NULL };
for_each_in_null_terminated_cstring_array(names, func);

I'm not really recommending this solution, though.

edit: Yes, more general is always more better, isn't it?

template <typename T, typename Function>
void for_each_in_null_terminated_array(T* array, Function f)
{
    while (*array) {
        f(*array);
        array++;
    }
}

---

(Here's the implementation of a null terminated ("false"-terminated) iterator I mentioned earlier - with a change or two based on suggestions below. It should be a real InputIterator)

template <class T>
class nt_iterator: public std::iterator<std::input_iterator_tag, T>
{
public:
    typedef typename nt_iterator<T>::pointer pointer;
    typedef typename nt_iterator<T>::value_type value_type;

    nt_iterator(): p(), pte(true) {}
    nt_iterator(pointer p_): p(p_), pte(!p_) {}
    nt_iterator(const nt_iterator<T>& rhs): p(rhs.p), pte(rhs.pte) {}
    nt_iterator<T>& operator++() {
        ++p;
        if (!*p) pte = true; // once pass-the-end, always pass-the-end
        return *this;
    }
    nt_iterator<T> operator++(int) {
        nt_iterator n(*this);
        operator++();
        return n;
    }
    bool operator==(const nt_iterator<T>& rhs) {
        return pte && rhs.pte || p == rhs.p;
    }
    bool operator!=(const nt_iterator<T>& rhs) {
        return !(operator==(rhs));
    }
    value_type operator*() { return *p; }

private:
    pointer p;
    bool pte; // past-the-end flag
};

And how it's used:

void print(const char* str);

int main()
{
    const char* array[] = {"One", "Two", "Three", NULL, "Will you see this?"};
    std::for_each(nt_iterator<const char*>(array),
                  nt_iterator<const char*>(),
                  print);
}

It's probably a bit slower than the loop version, because of the increased amount of equivalence checks - the speed difference is of course insignificant compared to, for example, printing text - but one should note that std::for_each does not magically make looping faster (in fact, you might be surprised to see how your compiler vendor defines the function - that is, if you are expecting too much).

Answer 5

There have been multiple answers that tell you what you can do instead. However the answer to your particular question is just "no, you can't" :)

Answer 6

Can you not replace the argument passed to func with a reference to a pointer to const char, in order to achieve what you want. Kind of like this:

const char *names[] = { "Bob", "Adam", "Simon" };

void func( const char* &arg )
{
   cout << arg << endl;
}

int main()
{
    for_each( names, 
              names + sizeof( names ) / sizeof( names[ 0 ] ), 
              func );
}

And obviously for a NULL-terminated string array, just subtract 1 from the array size...

Answer 7

template <class T>
struct NullTerminatedIterator {
  typedef NullTerminatedIterator<T> NTI;
  T * current;
  NTI & operator++() {current++; return this;}
  T & operator*() {return *current;} 
  NullTerminatedIterator(T * start): current(start) {}
  static NTI end() {return  NTI(0);}
  bool operator==(const NTI & that) {return current==that.current;}

}

Answer 8

Expanding on Basilevs answer with a fully working solution.

A custom iterator may be defined as follows:

template <class T>
class NullTerminatedIterator
    :public std::iterator<std::forward_iterator_tag,
    T,ptrdiff_t,const T*,const T&>
{
public:
    typedef NullTerminatedIterator<T> NTI;

    NullTerminatedIterator(T * start): current(start) {}
    NTI & operator++() {current++; return *this;}
    T & operator*() { return *current; } 
    static NTI end() { return NTI(0); }
    bool operator==(const NTI & that) { return *current == *that.current; }
    bool operator!=(const NTI & that) { return *current != *that.current; }
private:
    T * current;
};

And then used like so:

const char *names[] = {"Bob", "Adam", "Simon", NULL};

NullTerminatedIterator<char*> iter((char**)names);

for_each(iter, NullTerminatedIterator<char*>::end(), func);

The base class for the NullTerminatedIterator are taken from this custom iterator question.

This only traverses the list during the for_each call, as requested.