我目前已启动并运行此代码:

string word="test,";
string::iterator it = word.begin();
for (; it != word.end(); it++)
{
    if (!isalpha(*it)) {
        break;
    }
    else {
       *it = toupper(*it);
    }
}
word.erase(it, word.end());
// word should now be: TEST

我希望通过以下方式使其更加紧凑和可读:

1. 编写现有的标准C++算法(*)
2. 仅执行一次循环

(*)我假设结合现有算法使我的代码更具可读性......

另一种解决方案

除了定义自定义transform_until算法(如jrok所建议)之外,还可以定义一个自定义迭代器适配器,该适配器将使用底层迭代器进行迭代,但在返回之前通过修改底层引用来重新定义operator*().像这样的东西:

template <typename Iterator, typename UnaryFunction = typename Iterator::value_type (*)(typename Iterator::value_type)>
class sidefx_iterator: public std::iterator<
                         typename std::forward_iterator_tag,
                         typename std::iterator_traits<Iterator>::value_type,
                         typename std::iterator_traits<Iterator>::difference_type,
                         typename std::iterator_traits<Iterator>::pointer,
                         typename std::iterator_traits<Iterator>::reference >
{
  public:
    explicit sidefx_iterator(Iterator x, UnaryFunction fx) : current_(x), fx_(fx) {}

    typename Iterator::reference …

我有这个奇怪的问题(我在这里简化了代码)和clang 3.1(gcc工作正常).是不正当使用std :: function(通过值传递)还是clang bug？

template <typename Container>
struct A
{
  using function_type = std::function<char(char)>;

  A(Container c, function_type f) : it_(c.begin()), f_(f) {}
  typename Container::value_type operator*() { return *it_; }

  typename Container::iterator it_;
  function_type f_;
};

template <typename Cont>
A<Cont> makeA(Cont c, std::function<char(char)> f)
{
  return A<Cont>(c, f);
}

char f(char ch) { return ch; }

int main()
{
  std::string s { "foo" };
  auto a = makeA(s, f); // wraps s.begin()
  std::clog << "main: " << *(s.begin()) << std::endl; …