Constexpr查找实现

Constexpr find implementation

本文关键字：实现 查找 Constexpr      更新时间：2023-10-16

在回答了这个问题，阅读了这个演讲，看了这个代码之后，我想用一个简单的数组类来实现constexpr find。

考虑下面的例子:

#include <cstddef>
template <class It, class T>
constexpr auto constexpr_find(const It& b, const It& e, T value) {
    auto begin = b;
    while (begin != e) {
        if (*begin == value) break;
        ++begin;
    }
    return *begin;
}
template<typename T, size_t N>
class array
{
public:
   typedef T* iterator;
   typedef const T* const_iterator;
   constexpr auto begin() const { return const_iterator(array_); }
   constexpr auto end() const { return const_iterator(array_ + N); }
   T array_[N];
   static constexpr size_t size = N;
};
int main()
{
   constexpr array<int, 3> array{{0,2,3}};
   static_assert(constexpr_find(array.begin(), array.end(), 0) == 0, "");
}

按预期编译

和自定义constexpr迭代器:

template<class T>
class array_iterator
{
public:
   constexpr array_iterator(const T* v) : iterator(v)
   {
   }
   constexpr const T& operator * () const { return *iterator; }
   constexpr array_iterator& operator ++()
   {
      ++iterator;
      return *this;
   }
   constexpr bool operator != (const array_iterator& other) const { return iterator != other.iterator; }
private:
   const T* iterator;
};

在数组中:

typedef const array_iterator<const T> const_iterator;

这是唯一的区别，编译器给我错误:

的constexpr展开中的

constexpr_find<array_iterator<const int>, int>(array.array<T, N>::begin<int, 3u>(), array.array<T, N>::end<int, 3u>(), 0)

error: (((const int*)(& array.array<int, 3u>::array_)) != (((const int*)(& array.array<int, 3u>::array_)) + 12u))不是常数表达

生活例子

这是gcc bug，因为clang编译得很好，还是两个片段有区别?

我不能确定，但是您将数组成员的指针存储到外部迭代器类中，这可能是导致该错误的原因。

--------- update start ---------

下面是演示这个问题的最小代码片段: 
constexpr const struct A { int i[2]; } a {{0,0}};
int main ()
{
  static_assert (nullptr != a.i  , ""); // ok
  static_assert (nullptr != a.i+0, ""); // ok
  static_assert (nullptr != a.i+1, ""); // error
}

在常量表达式中，指针指向数组元素(偏移量非零)似乎是被禁止的。

--------- update end ---------

解决方法很简单——存储指向数组对象的指针和偏移量。

生活
#include <cstddef>
template <class It, class T>
constexpr auto constexpr_find(const It& b, const It& e, T value) {
    auto begin = b, end = e;
    while (begin != end) {
        if (*begin == value) break;
        ++begin;
    }
    return *begin;
}
template<class Array>
class array_iterator
{
public:
   constexpr array_iterator(const Array& a, size_t pos=0u) : array_(&a), pos_ (pos)
   {
   }
   constexpr const typename Array::value_type& 
   operator * () const { return (*array_)[pos_]; }
    constexpr array_iterator& operator ++()
   {
      ++pos_;
      return *this;
   }
   constexpr bool operator != (const array_iterator& other) const 
   { return array_ != other.array_ || pos_ != other.pos_; }
private:
   const Array* array_;
   size_t pos_;
};
template<typename T, size_t N>
class array
{
public:
   typedef T value_type;
   typedef const array_iterator<array> const_iterator;
   constexpr T const& operator[] (size_t idx) const { return array_[idx]; }
   constexpr auto begin() const { return const_iterator(*this); }
   constexpr auto end() const { return const_iterator(*this, N); }
   T array_[N];
   static constexpr size_t size = N;
};
int main()
{
   constexpr array<int, 3> array{{0,2,3}};
   static_assert(constexpr_find(array.begin(), array.end(), 0) == 0, "");
}

顺便说一下，可以实现c++ 11版本的constexpr启用find:

生活
#include <cstddef>
#include <cassert>
#if !defined(__clang__) && __GNUC__ < 5
// TODO: constexpr asserts does not work in gcc4, but we may use 
// "thow" workaround from 
// http://ericniebler.com/2014/09/27/assert-and-constexpr-in-cxx11/
# define ce_assert(x) ((void)0)
#else
# define ce_assert(x) assert(x)
#endif
namespace my {
template <class It, class T>
inline constexpr It
find (It begin, It end, T const& value) noexcept
{
    return ! (begin != end && *begin != value)
         ? begin
         : find (begin+1, end, value);
}
template<class Array>
class array_iterator
{
public:
  using value_type = typename Array::value_type;
  constexpr array_iterator(const Array& array, size_t size = 0u) noexcept
    : array_ (&array)
    , pos_ (size)
  {}
  constexpr const value_type operator* () const noexcept
  {
    return ce_assert (pos_ < Array::size), (*array_) [pos_];
  }
#if __cplusplus >= 201402L // C++14
  constexpr
#endif
  array_iterator& operator ++() noexcept
  {
    return ce_assert (pos_ < Array::size), ++pos_, *this;
  }
  constexpr array_iterator operator+ (size_t n) const noexcept
  {
    return ce_assert (pos_+n <= Array::size), array_iterator (*array_, pos_+n);
  }
  friend constexpr bool
  operator != (const array_iterator& i1, const array_iterator& i2) noexcept
  {
    return i1.array_ != i2.array_ || i1.pos_ != i2.pos_;
  }
  friend constexpr size_t
  operator- (array_iterator const& i1, array_iterator const& i2) noexcept
  {
    return ce_assert (i1.array_ == i2.array_), i1.pos_ - i2.pos_;
  }
private:
  const Array* array_;
  size_t pos_;
};
template<typename T, size_t N>
class array
{
public:
  using value_type = T;
  using const_iterator = const array_iterator<array>;
  constexpr value_type const&
  operator[] (size_t idx) const noexcept
  { return array_[idx];  }
  constexpr const_iterator begin() const noexcept
  { return const_iterator(*this); }
  constexpr const_iterator end()   const noexcept
  { return const_iterator(*this, N); }
  T array_[N];
  static constexpr size_t size = N;
};
}
int main()
{
  static constexpr my::array<int, 3> array{{0,2,3}};
  static_assert (
    find (array.begin(), array.end(), 2) - array.begin () == 1,
    "error");
}

您可能也有兴趣检查Sprout库，它包含许多constexpr数据结构和算法。

相关文章：