blog review 第一期

struct foo {
    foo(int i) : data(i) {}
    friend inline std::ostream& operator<<(std::ostream& os,
                                           foo const& f)
    { return os << "foo(" << f.data << ")"; }
private:
    int data;
};
// 典型，笨拙
std::array<foo, 10> arr;
for (int i = 0; i < arr.size(); ++i)
    arr[i] = foo(i);
// 不能编译，因为有十个，你只提供了一个构造，推导不出init list。引入默认构造也不是一个好点子
// 因为需要各种值
std::array<foo, 10> arr {};

//典型vector方案
std::vector<foo> vec;
vec.reserve(10);
std::generate_n(std::back_inserter(vec), 10,
                [i=0]() mutable -> foo { return i++; });

template <typename Container, int... I>
Container iota_impl(std::integer_sequence<int, I...>) {
    return {I...};
} 

template <typename T, size_t N>
auto iota_array() {
    using Sequence = std::make_integer_sequence<int, N>;
    return iota_impl<std::array<T, N>>(Sequence{});
}

auto arr = iota_array<foo, 10>();
std::copy(arr.begin(), arr.end(),
          std::ostream_iterator<foo>{std::cout, ", "});
/* output: foo(0), foo(1), foo(2), foo(3), foo(4), ... */

template <typename T, size_t N, size_t... I>
auto subarray_impl(std::array<T, N> const& arr,
                   size_t first,
                   std::index_sequence<I...>)
    -> std::array<T, sizeof...(I)>
{
    return {arr[first + I]...};
}

template <size_t S, typename T, size_t N>
auto subarray(std::array<T, N> const& arr, size_t first) {
    using Indices = std::make_index_sequence<S>;
    return subarray_impl(arr, first, Indices{});
}

auto sub = subarray<4>(arr, 2);
/* foo(2), foo(3), foo(4), foo(5) */

std::string const& my_to_string(std::string const& s)
{
    return s;
}

template<typename T>
std::string my_to_string(T const& value)
{
    return std::to_string(value);
}

template<typename Range>
std::string my_to_string(Range const& range)
{
    std::ostringstream result;
    for (auto const& value : range)
    {
        result << value << ' ';
    }
    return result.str();
}

auto my_to_string = boost::hof::first_of(
    [](std::string const& s) -> std::string const&
    {
        return s;
    },
    [](auto const& value) -> decltype(std::to_string(value))
    {
        return std::to_string(value);
    },
    [](auto const& range)
    {
        std::ostringstream result;
        for (auto const& value : range)
        {
            result << value << ' ';
        }
        return result.str();
    }
);

class Circle
{
public:
    explicit Circle(double radius) : radius_(radius) {}
    
    double radius() const { return radius_; };

    // rest of the Circle’s interface
    
private:
    double radius_;    
};

auto const input = std::vector<double>{1, 2, 3, 4, 5};
auto results = std::vector<Circle>{};

std::transform(begin(input), end(input), back_inserter(results), boost::hof::construct<Circle>());

std::sort(begin(circles), end(circles), [](Circle const& circle1, Circle const& circle2)
                                        {
                                            return circle1.radius() < circle2.radius();
                                        }); // 1
std::ranges::sort(circles, {}, &Circle::radius_); //2
using namespace boost::hof;
std::sort(begin(circles), end(circles), proj(&Circle::radius, _ < _)); //3

int plusOne(int i)
{
    return i + 1;
}

int timesTwo(int i)
{
    return i * 2;
}

auto const input = std::vector<int>{1, 2, 3, 4, 5};
auto results = std::vector<int>{};

std::transform(begin(input), end(input), back_inserter(results), boost::hof::compose(timesTwo, plusOne));

//当然c++20也足够优雅
auto const input = std::vector<int>{1, 2, 3, 4, 5};

auto range = inputs
                | std::views::transform(plusOne)
                | std::views::transform(timesTwo);

auto result = std::vector<int>{range.begin(), range.end()};

g(f1(), f2()); //不一定保证顺序
boost::hof::apply_eval(g, [](){ return f1(); }, [](){ return f2(); });//保证顺序

template<typename _ForwardIterator, typename _Tp, typename _Compare>
_GLIBCXX20_CONSTEXPR
_ForwardIterator
__upper_bound(_ForwardIterator __first, _ForwardIterator __last,
              const _Tp& __val, _Compare __comp)
{
  typedef typename iterator_traits<_ForwardIterator>::difference_type
    _DistanceType;

  _DistanceType __len = std::distance(__first, __last);

  while (__len > 0)
  {
    _DistanceType __half = __len >> 1;
    _ForwardIterator __middle = __first;
    std::advance(__middle, __half);
    if (__comp(__val, __middle))
      __len = __half;
    else
    {
      __first = __middle;
      ++__first;
      __len = __len - __half - 1;
    }
  }
  return __first;
}
 template <class T> INLINE size_t fast_upper_bound0(const vector<T>& vec, T value)
{
  return std::upper_bound(vec.begin(), vec.end(), value) - vec.begin();
}

template <class T> INLINE size_t fast_upper_bound1(const vector<T>& vec, T value)
{
    size_t size = vec.size();
    size_t low = 0;

    while (size > 0) {
        size_t half = size / 2;
        size_t other_half = size - half;
        size_t probe = low + half;
        size_t other_low = low + other_half;
        T v = vec[probe];
        size = half;
        low = v >= value ? other_low : low;
    }

    return low;
}

template <class T> INLINE size_t choose(T a, T b, size_t src1, size_t src2)
{
#if defined(__clang__) && defined(__x86_64)
    size_t res = src1;
    asm("cmpq %1, %2; cmovaeq %4, %0"
        :
    "=q" (res)
        :
        "q" (a),
        "q" (b),
        "q" (src1),
        "q" (src2),
        "0" (res)
        :
        "cc");
    return res;
#else
    return b >= a ? src2 : src1;
#endif
}

template <class T> INLINE size_t fast_upper_bound2(const vector<T>& vec, T value)
{
    size_t size = vec.size();
    size_t low = 0;

    while (size >= 8) {
        size_t half = size / 2;
        size_t other_half = size - half;
        size_t probe = low + half;
        size_t other_low = low + other_half;
        T v = vec[probe];
        size = half;
        low = choose(v, value, low, other_low);

        half = size / 2;
        other_half = size - half;
        probe = low + half;
        other_low = low + other_half;
        v = vec[probe];
        size = half;
        low = choose(v, value, low, other_low);

        half = size / 2;
        other_half = size - half;
        probe = low + half;
        other_low = low + other_half;
        v = vec[probe];
        size = half;
        low = choose(v, value, low, other_low);
    }

    while (size > 0) {
        size_t half = size / 2;
        size_t other_half = size - half;
        size_t probe = low + half;
        size_t other_low = low + other_half;
        T v = vec[probe];
        size = half;
        low = choose(v, value, low, other_low);
    };

    return low;
}