0

我在这里回答了一个问题：https ://stackoverflow.com/a/28862668/2642059我需要使用循环来逐步完成string. 我想const string&在每个函数上使用 a 作为我的参数，但除非我想在每次递归时重建字符串，否则我发现我需要传递 astart和finish位置以及它string本身。因此，通过根本变得毫无意义string。

最后，我选择只将 astart和finish指针传递给char[].

例如，假设我得到一个包含嵌套括号的字符串（但没有并排插入的括号。）所以像这样：

(abc(def(ghi((j)klm)nop)qrs)tuv)wxyz

但不是这样：

(abc(def)(ghi)(j)(klm)(nop)(qrs)tuv)wxyz

我想编写一个递归程序来提取最深嵌套括号中的字符串。就像是：

string foo(const string& bar){
    auto start = bar.find('(') + 1;

    return start == string::npos + 1 ? bar : foo(bar.substr(start, bar.find_last_of(')') - start));
}

但是，我不高兴string为foo. 另一种方法是像链接示例中那样传递start和finish指针（或传递string::const_iterators。）

是否有包装器或其他东西可以让我使用string功能，但不能重建 a string？

4

2 回答 2

3

string_view从库基础 TS 可能是一个想法，GCC 中提供了支持。

界面几乎与string

#include <experimental/string_view>
using std::experimental::string_view;

string_view foo(const string_view& bar){
    auto start = bar.find('(') + 1;

    return start == string_view::npos + 1 ? bar : foo(bar.substr(start, bar.find_last_of(')') - start));
}

最后一行也可以是

return start ? foo(bar.substr(start, bar.find_last_of(')') - start)) : bar;

虽然他们都很神秘。

于 2015-03-12T11:02:22.457 回答
1

自己写array_view<T>。这是几十行代码。

用于std::find替换这两种算法。在一种情况下，使用反向迭代器。（或编写基于范围的查找和基于范围的backwards）

使用{T*,T*}ctor 进行递归。

array_view<const char> foo(array_view<const char> bar)

这是一个原语array_view<T>：

template<class T>
struct array_view {
  using mutable_T = typename std::remove_reference<T>::type;
  // 3 primitive functions:
  T* begin() const { return b; }
  T* end() const { return e; }
  array_view(T* s, T* f):b(s), e(f) {};
  // everything else based on them:
  size_t size() const { return end()-begin(); }
  array_view(T* s, size_t l):array_view(s,s+l) {}
  array_view():array_view(nullptr,  nullptr) {}
  // repeat next 3 for string, array, initializer list, C array as required:
  template<class A>
  array_view( std::vector<T,A>& v ):array_view(v.data(), v.size()) {}
  // may not compile for non-const T, but that is ok  you get an error:
  template<class A>
  array_view( std::vector<mutable_T,A>const & v ):array_view(v.data(), v.size()) {}
  // in a better world, you'd SFINAE remove the above from consideration
  // consider it for your next iteration of array_view.
  // conversion to containers:
  template<class A>
  explicit operator std::vector<mutable_T,A>() const {
    return convert_to< std::vector<mutable_T, A> >();
  }
  template<class C>
  C convert_to() const {
    C retval(begin(), end());
    return retval;
  }

  // utility functions:
  T& front() const { return *begin(); }
  T& back() const { return std::prev(*end()); }
  // Also rbegin, rend, and whatever else you find you are missing

  // inspired by std::experimental:
  void pop_front() { *this = {std::next(begin()), end()}; }
  void pop_back() { *this = {begin(), std::prev(end())}; }
  // but I find direct use of `view = {x,y}` almost as good
  // these kind of operations are the ONLY ones that are non-const
  // remember this is a view.  If you want a view of const data, make it
  // an array_view<const T>, not a const array_view<T>.  It really works
  // out better.
private:
  T* b
  T* e;
};

以上示例代码未经测试。

于 2015-03-12T12:29:45.933 回答