向 C++ 添加语法糖

Question

编辑 2：

新编辑：看起来 C++20 有一个新的范围库，从功能的角度来看，它可以满足我的需求。如何在 C++17 或更早版本上完成类似的操作？另外，Kotlin 语法糖可能吗？主要是人的例子：

val adam = Person("Adam").apply { 
    age = 20 // same as this.age = 20 or adam.age = 20
    city = "London"
}

编辑 1：

我不知道我的问题是否那么清楚，所以我将使用 Rust 的 map 举一个例子。

这是在 rust 中制作地图的方式：

let newVector = myVector.iter().map(|x|, x * 2)

这就是它在 C++ 中的实现方式

std::string s("hello");
std::vector<std::size_t> ordinals;
std::transform(s.begin(), s.end(), std::back_inserter(ordinals),
     [](unsigned char c) -> std::size_t { return c; });

这要冗长得多。

我想添加一些语法糖来做这样的事情：

std::string s("hello");
auto ordinals = my_ns::map(s,[](unsigned char c) -> std::size_t { return c; });

my_ns::map 的实现可能是这样的（我敢肯定这行不通，只是为了说明如何实现）

template<typename T, U>
map(T t, std::function<U> f)
{
    std::vector<U> ordinals;
    std::transform(t.begin(), t.end(), std::back_inserter(ordinals),
     [](U c) -> f(c));
    return ordinals;
}

在这种情况下，ordinals 不需要是 std::vector<std::size_t> 类型，它可以是 map 类型，它具有 std::vector<T> 的转换。使用类型映射的原因是能够将 reduce 与映射等函数链接起来。

原始问题

注意：这仅适用于个人项目，我不打算在生产或大多数时间使用 C++ 时使用它。

我最近一直在使用很多 Kotlin，并且正在尝试使用 Rust，我喜欢它们的高级功能。这让我想知道，我可以创建一些语法糖来模拟其中的一些功能吗？

我试图模仿的一些东西（只是一个例子）

锈图：

let newVector = myVector.iter().map(|x|, x * 2)

Kotlin 让

val adam = Person("Adam").apply { 
    age = 20 // same as this.age = 20 or adam.age = 20
    city = "London"
}

val str = "Hello"
str.let {
   println("The string's length is ${it.length}")
}

我不打算使用完全相同的语法，但我想知道是否可以执行以下操作：

int[] arr = {1, 2, 3};
auto d_arr = map(arr, [](int x){return x*2}) // maybe return a map type to be able to use .reduce, etc

第一个 kotlin let 示例我不知道该怎么做，但第二个也可以使用 lambdas 解决。

我正在考虑使用新类型并创建到 std::vector 和数组的转换，这与 C# 的 LINQ 的工作原理类似。

感谢任何有关如何执行此操作的提示。

Ps：我知道 std::transform 和其他功能（我可能会在实现时使用它们），但我想要一个比提供的更简单的 API（而且我也认为这会很好个人项目）。

Answer 1

您的示例可以很容易地更改为工作 C++ 代码：

template <typename T, typename Fun> auto map(T t, Fun f) {
  std::vector<typename T::value_type> ordinals;
  std::transform(t.begin(), t.end(), std::back_inserter(ordinals), f);
  return ordinals;
}

这既不是非常惯用的，也不是针对性能进行优化的，但它确实有效。 （预先调整向量的大小，而不是使用 std::back_inserter 并通过引用传递 t 以大幅提升性能。）

编辑：可以添加reduce如下：

template <typename T, typename R, typename Fun> auto reduce(T t, R init, Fun f) {
  return std::transform(t.begin(), t.end(), init, f);
}

然后将它们组合起来：reduce(map(x, [](auto a) {...}), 0, [](int& a, auto b) {...})

明显的警告：这将非常缓慢。这些函数学习模板概念很有趣，但在实践中，范围或旧式 std::reduce/... 会快得多。

编辑 2： 如果你想使用map作为成员函数，只需做一个包装类：

template<class T>
struct Wrapper {
  T d;
  template <typename Fun> auto map(Fun f) {
    std::vector<typename T::value_type> ordinals;
    std::transform(d.begin(), d.end(), std::back_inserter(ordinals), f);
    return wrap(ordinals);
  }
  template <typename R, typename Fun> auto reduce(R init, Fun f) {
    return wrap(std::transform(d.begin(), d.end(), init, f));
  }
};
template<class T> Wrapper<T> wrap(const T& t) { return {t}; }
template<class T> Wrapper<T> wrap(T&& t) { return {t}; }

那你就可以wrap(my_vec).map(...).reduce(..., ...)

for 循环在这里会更快，因为你做了很多不必要的复制：你不必要地在 map 中创建一个新向量并复制数据很多次（std::back_inserter，pass-by-值）。

Answer 2

我想知道是否可以这样做：

int[] arr = {1, 2, 3};
auto d_arr = map(arr, [](int x){return x*2})

在这个意义上的“map”在 C++ 标准库中被称为“transform”。一个工作示例：

auto double_ = [](auto x){ return x*2; }; // you may also use a normal function
auto doubled_view = std::views::all(arr)
                  | std::views::transform(double_);

能够将reduce等函数与map链接起来。

您可以缩小范围。不幸的是，C++20 标准范围没有附带 reduce 函数，因此必须使用范围的另一种实现，或者改用基于迭代器的函数。后者的例子：

auto sum = std::reduce(
     std::execution::unseq, // optional execution policy
     doubled_view.begin(),
     doubled_view.end(),
     0
     // you can use a functor to do something other than add
     );

转换为 std::vector

您还可以从范围创建容器：

std::vector doubled_vector(
    doubled_view.begin(), doubled_view.end());

请注意，为范围视图的中间阶段创建容器可能会产生不必要的开销。