名单 <Char> 在C ++中输入constexpr字符串

Question

我试图使用constexpr在C ++中使用函数式编程语言模拟类似列表结构的cons-cell 。 我有一pair类型，首先。 这是两个不同的东西的持有者，但也支持嵌套对。 这是代码。

template <typename E1, typename E2>
struct pair {

    constexpr pair() 
    :_car{E1{}}, _cdr{E2{}}
    {}

    constexpr pair(const E1 &car, const E2 &cdr)
    :_car{car}, _cdr{cdr}
    {}

    constexpr auto car() const{
        return _car;
    }

    constexpr auto cdr() const{
        return _cdr;
    }

    friend std::ostream& operator<<(std::ostream& str,
                                    pair<E1, E2> p){
        if(p == pair{})
            return str;
        str << p.car() << " " << p.cdr();
        return str;
    }

    template <typename Functor>
    friend constexpr auto fmap(Functor f,
                               const pair<E1, E2> p){
        if constexpr (std::is_fundamental<E1>::value &&
                      std::is_fundamental<E2>::value)
            return pair{f(p.car()), f(p.cdr())};
        else if(std::is_fundamental<E1>::value &&
                !std::is_fundamental<E2>::value)
        return pair{f(p.car()), fmap(f, p.cdr())};
    }

    const E1 _car;
    const E2 _cdr;
};

template <typename E1, typename E2>
constexpr bool operator==(const pair<E1, E2>& p1, const pair<E1, E2>& p2)
{
    return (p1.car() == p2.car()) && (p1.cdr() == p2.cdr());
}

作为这种类型的包装器，我有一个nested_pair类型。 这使我更容易使用nested_pair的.aka列表。 实际列表只是这个包装器的一个typedef。 这是代码。

template <typename Head, typename Tail>
class nested_pair{
    public:

    constexpr nested_pair():p{}
    {}

    constexpr nested_pair(Head h, Tail t)
    :p{h, t}
    {}

    constexpr auto prepend(Head h) const{ 
        return nested_pair<Head, decltype(p)>{h, p};
    }

    constexpr auto head() const {
        return p.car();
    }

    constexpr auto tail() const {
        return nested_pair<decltype(p.cdr().car()),
                    decltype(p.cdr().cdr())>
                    {p.cdr().car(),
                     p.cdr().cdr()
                    };
    }

    constexpr bool is_empty() const {
        return p == pair<decltype(p.car()),
                         decltype(p.cdr())>
                         {};
    }

    template <typename Functor>
    friend constexpr auto fmap(Functor f, const nested_pair l) {
        const auto res = fmap(f, l.p);
        return nested_pair{res.car(), res.cdr()};
    }

    friend std::ostream& operator<<(std::ostream& str,
                                    nested_pair<Head, Tail> l){
        str << l.p;
        str << "\n";
        return str;
    }

    private:
    const pair<Head, Tail> p;
};

我的nested_pair只允许prepend，因为如果你将列表存储为一对head和tail，append需要O（n）递归调用。 在这里，我将大量工作委托给包装pair的n pair和nested_pair构造函数。 我相信这些工作很好。 我使用以下变量模板将列表定义为嵌套对。

template <typename T>
using list = nested_pair<T, T>;

现在，问题的本质，我想使用此list来创建string类型，如list<char> 。 这应该是所有constexpr，尽我们所能。 我有一个其他版本的const char []来构建constexpr字符串，但现在我想使用结构递归。 这是我失败的尝试。

class lstring{
    public:

    template <std::size_t N>
    constexpr lstring(const char(&cont)[N]) :size{N} {
        size_t ind = N - 1;
        while(ind >= 0){
            content = content.prepend(cont[ind]);
            ind--;
        }
    }

    private:
    const size_t size;
    const list<char> content;
};

当然这不起作用。 constexpr构造函数经历了一个while循环并违反了constexpr的规则，我相信我们不能在constexpr函数中循环。 这也不利用列表的递归结构。 如何以这种方式构造字符串？ 我应该使用带有char... args的可变参数模板吗？ 我怎样才能在结构上拆开它？ 我希望能够从像list<char> s{"hello world"}这样的字符串文字中初始化它。

Answer 1

你有一个概念问题：

你的lstring包含一个list<char> ，它实际上是一个nested_pair<char, char> ，它又包含一pair<char, char> 。 你的字符串总是包含两个char 。

字符串类和列表类都需要将它们的长度编码为其类型的一部分。 即你需要一个list<char, 5>作为5个char的列表（因此包含一pair<char, pair<char, pair<char, pair<char, char>>>> ）。 否则，你需要动态内存-这是编译时常码明确否定的 。

---

现在，进行演示。 我希望它会给你一些关于如何实现某些事情的想法。 这对我来说也很有趣;）与你的设计选择相反，我选择了一个特殊的哨兵值 - nil - 来标记列表的结尾。 以下所有代码都在namespace list ：

 struct nil {
  template<typename U>
  constexpr auto prepend(U && u) const;
 };

nil （空列表）有一个成员函数模板，用于向前面添加内容。 它只是声明 - 未定义 - 来打破循环依赖。

注意：这里是否使用会员功能或免费功能是个人品味/风格的问题。 通常我会使用自由函数（ prepend(mylist, element) ）但我想反映你的预期用法（ mylist.prepend(element) ）。

接下来是最重要的结构 - “对” - 构建列表。 以Lisp的cons细胞命名：

 namespace implementation {
  template<typename T>
  using no_ref_cv = std::remove_cv_t<std::remove_reference_t<T>>;
 }

 template<typename Car, typename Cdr>
 struct cons {
  Car car;
  Cdr cdr;

  template<typename U>
  constexpr auto prepend(U && u) const {
   using implementation::no_ref_cv;
   return cons<no_ref_cv<U>, cons<Car, Cdr>>{std::forward<U>(u), *this};
  }
 };

这只是一对简单的。 prepend创建了一个新的缺点，新元素作为它的第一个元素和当前缺点的（副本），因为它是第二个。 我删除了const和volatile因为它有点令人头疼（尝试弄清楚为什么cons<char, cons<char, cons<const char, cons<char, nil>>>>不会转换为cons<char, cons<const char, cons<char, cons<char, nil>>>> ）

也就是说， nil::prepend的实现基本相同：

 template<typename U>
  constexpr auto nil::prepend(U && u) const {
   using implementation::no_ref_cv;
   return cons<no_ref_cv<U>, nil>{std::forward<U>(u), *this};
  }

我也喜欢自由功能来“制造”东西，所以：

 template<typename Car, typename Cdr>
 constexpr auto make_cons(Car && car, Cdr && cdr) {
  using implementation::no_ref_cv;
  return cons<no_ref_cv<Car>, no_ref_cv<Cdr>>{
    std::forward<Car>(car), std::forward<Cdr>(cdr)};
 }

现在，问你的问题：

我怎样才能在结构上拆开它？ 我希望能够从像list<char> s{"hello world"}这样的字符串文字中初始化它。

list<char>是不可能的（记住 - 你也需要它的长度！）。 但是auto s = list::make_list("hello world") 。

您已经有代码来获取字符串文字的长度（参数类型CharT (&array)[N] ），使用该N可以构建一个具有足够嵌套cons的类型来保存您的列表：

 namespace implementation {
  template<typename T, std::size_t N>
  struct build_homo_cons_chain {
   using type = cons<T, typename build_homo_cons_chain<T, N - 1u>::type>;
  };

  template<typename T>
  struct build_homo_cons_chain<T, 0u> {
   using type = nil;
  };
 }

N == 0只是一个nil （空列表），其他一切都是元素的cons和长度为N - 1的列表。 这允许您为列表定义正确的类型，您可以使用它来默认初始化它的实例，然后循环遍历car成员以填充它。 像这样的东西：

using list_t = typename implementation::build_homo_cons_chain<char, N>::type;
list_t my_new_list;
// fill my_new_list.car, my_new_list.cdr.car, ... probably with recursion

这种方法的问题是您需要列表的元素类型既可以是默认可构造的，也可以是可分配的。 对于char不是问题，但这些都是严格的要求，所以当我们从数组中提供的元素（字符串文字）中复制/移动构造列表的元素时，我们会更好：

 namespace implementation {
  template<std::size_t O, std::size_t C>
  struct offset_homo_builder {
   template<typename T, std::size_t N>
   constexpr auto from( T (&array)[N]) {
    return offset_homo_builder<O - 1u, C - 1u>{}.from(array).prepend(array[N - O]);
   }
  };
  template<std::size_t O>
  struct offset_homo_builder<O, 0u> {
   template<typename T, std::size_t N>
   constexpr auto from( T (&array)[N]) {
    return nil{};
   }
  };
 }

O是相对于数组末尾的偏移量， C是我们仍需要构建列表的缺点。 from成员函数模板采用长度为N的数组，并将元素从N - O处的数组预先添加到它以递归方式构建的（较短）列表中。

示例： implementation::offset_homo_builder<3,2>::from("ab")

offset_homo_builder<3,2>::from("ab") --> N = 3, O = 3, C = 2
: cons{'b', nil}.prepend('a') => cons{'a', cons{'b', nil}}
  ^
  |--- offset_homo_builder<2, 1>::from("ab") --> N = 3, O = 2, C = 1
       : nil.prepend('b') => cons{'b', nil}
         ^
         |--- offset_homo_builder<1, 0>::from("ab") --> N = 3, O = 1, C = 0 (!specialisation!)
              : nil

C计数对于在字符串文字的末尾省略'\\0'很重要。 所以现在你可以创建一个包含数组所有元素的列表：

 template<typename T, std::size_t N>
 constexpr auto make_homogenous(T (&array)[N]) {
  return implementation::offset_homo_builder<N, N>{}.from(array);
 }

或者构建一个字符串，其中遗漏了最后一个元素：

 template<std::size_t N, typename CharT, typename = typename std::char_traits<CharT>::char_type>
 constexpr auto make_string(CharT (& array)[N]) {
  static_assert(N > 0, "assuming zero terminated char array!");
  return implementation::offset_homo_builder<N, N - 1>{}.from(array);
 }

最后，要使用此列表，您不需要查看元素的类型。 只需停在nil ：

 template<typename F, typename Car, typename Cdr>
 constexpr auto fmap(F functor, cons<Car,Cdr> const & cell) {
  return make_cons(functor(cell.car), fmap(functor, cell.cdr));
 }
 template<typename F>
 constexpr auto fmap(F functor, nil const &) {
  return nil{};
 }

foldl ， foldr和friends可以类似地实现。 您的operator<<可以使用foldl实现。

namespace list结尾。

另外，检查我们是否仍然是constexpr ：

constexpr char inc(char c) {
 return c + 1;
}

static_assert(fmap(inc, list::make_string("ab").prepend('x')).car == 'y', "");

注意参数依赖查找 （ADL）的美妙...我可以说fmap而不是list::fmap 。 适用于通用代码。