使用for_each迭代一个以NULL结尾的字符串是可行的：
const char *name = "Bob";
void func(const char &arg)
{
cout << arg;
}
int main()
{
for_each(name, name + strlen(name), func);
}
对于以NULL结尾的字符串列表（无需先确定列表的总长度），是否有类似的方法可行？例如：
const char *names[] = { "Bob", "Adam", "Simon", NULL };
std::for_each可以在范围内"迭代"，所以如果要将其与长度不确定的数组一起使用，则需要使用自定义迭代器来指示数组的结尾（即NULL成员）。如果您坚持使用以NULL结尾的char*数组，当然可以为其创建自己的for_each函数，例如如下：
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);
我并不是真正推荐这种解决方案。
编辑：是的，更通用总是更好的，不是吗？
template <typename T, typename Function>
void for_each_in_null_terminated_array(T* array, Function f)
{
while (*array) {
f(*array);
array++;
}
}
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 past-the-end, always past-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
};
以及它的使用方式：
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);
}
使用std::for_each可能会比循环版本慢一点，因为需要增加等价性检查的数量。当然，与例如打印文本相比，速度差异微不足道，但应注意std::for_each并不能神奇地使循环更快（实际上，如果您期望过高，您可能会惊讶地看到编译器供应商如何定义该函数）。
== NULL，而应该依赖于operator!或== T()，例如，pte = !*p;。此外，指定通用的过去结束迭代器的通常方法是使用默认构造函数，例如std::istream_iterator。 - Jon Purdypte = !*p，但我考虑到所有指针，并且认为它似乎太棘手了 - 尽管这是我在自己的代码中使用的版本 ;) - eq-pte 的初始化中丢失了一个 * 吗？ 应该是 pte(!*p_)，对吧？ 在这个例子中，T 是一个 const char *，所以 pointer 应该是 const char * *，对吗？ - Adrian McCarthy带有
const char *names[] = { "Bob", "Adam", "Simon" };
std::for_each(names, names + sizeof(names)/sizeof(names[0]), func );
std::for_each(begin(names), end(names), func );
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 );
func()能够处理NULL参数。 - sbisizeof来完成这个任务。 - Fred Foo在Basilevs的答案基础上，进一步提供一个完整可用的解决方案。
可以定义一个自定义迭代器如下所示:
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;
};
然后像这样使用：
const char *names[] = {"Bob", "Adam", "Simon", NULL};
NullTerminatedIterator<char*> iter((char**)names);
for_each(iter, NullTerminatedIterator<char*>::end(), func);
NullTerminatedIterator的基类取自于这个定制迭代器问题。
这只在for_each调用期间遍历列表，正如所请求的那样。
已经有多个答案告诉你可以做什么。然而，对于你的特定问题，答案只是“不行，你不能” :)
你可以使用 sizeof() 函数来处理编译时确定大小的数组。
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();
对于动态大小的数组，您应该使用std::vector<std::string>并对其进行迭代。
请原谅我使用lambda表达式，您的编译器（可能）不支持它们。
相反，将它们添加到容器中，并使用 for_each 进行迭代。
我在示例中使用了 vector：
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;
}
你能否将传递给函数的参数替换为对指向const char的指针的引用，以实现你想要的效果。就像这样：
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 );
}
显然，对于以NULL结尾的字符串数组，只需从数组大小中减去1即可...
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;}
}
// C version
const char* vars[16]={"$USER","$HOME","$DISPLAY","$PASSWORD",0};
for(const char** pc = vars; *pc!=0; pc++)
{
printf("%s",*pc);
}
我知道这不是for_each，但我想使用旧的常规for循环来完成相同的操作。这个来自MSDN博客：
将双null终止字符串重新解释为一个带有空字符串作为终止符的字符串列表，使得编写遍历双null终止字符串的代码非常简单：
for (LPTSTR pszz = pszzStart; *pszz; pszz += lstrlen(pszz) + 1) {
// ... do something with pszz ...
}
对我来说看起来很干净！
std::list<std::string>（如果更适合则使用std::vector）表示。这将一次性解决您所有的问题。 - Björn Pollex