递归传递字符串而不进行娱乐

Pass a string Recursively without Recreation

本文关键字：娱乐 字符串 递归      更新时间：2023-10-16

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

最后，我选择只传递一个start和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));
}

但是，我不高兴为每次foo的重复重建string。另一种方法是传递start和finish指针，如链接示例中所示（或传递string::const_iterator s）。

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

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;

虽然它们都非常神秘。

编写自己的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;
};

上面的示例代码未经过测试。

相关文章：