将推导出的类型作为r值引用传递时,我会获得通用引用功能,并且可以像这样完美转发:
template <typename T>
void func(T&& t) {
other_func(std::forward<T>(t));
}
...由于T的推导方式和标准的参考折叠规则.
现在考虑other_func采用一个函数对象
template <typename T>
void func(T&& t) {
other_func([](int v) { return t + v; }); // I chose addition for example purposes
}
现在很明显,由于没有被捕获,这将无法编译.我的问题是:我如何捕获它,以便捕获的值将是推断出的T值？
这是否可以使用新的通用lambda捕获？如果......怎么样？
[t = std::forward<T>(t)] ?
我仍然没有真正掌握新捕获初始化器的机制......
是否可以通过通用引用传递模板模板参数值？例如,考虑处理STL序列的函数(非)的这个最小示例:
#include <iostream>
#include <vector>
template < template<typename,typename> class C, template<typename> class A, typename T >
void func(C<T, A<T>>&& c) {
// usually I'd std::forward here, but let's just use cout...
std::cout << c.size() << "\n";
}
int main (int argc, char const* argv[]) {
func(std::vector<float>(2));
std::vector<float> lv(3);
func(lv);
}
它不会编译,因为编译器不知道如何在第二次调用func时绑定l值("lv").当涉及C类型的演绎规则时,我有点迷失了.任何人都可以启发我吗？
编辑:虽然我猜这与问题无关:我使用g ++ 4.9和clang 3.5(两个repo HEAD)
假设我有一系列名为rng的T.我可以
auto groups = ranges::view::group_by(rng, bin_op);
群体现在是T的范围.
我也可以这样做
auto groups = ranges::view::group_by(rng, bin_op) | ranges::to_vector;
得到T的范围向量.不过这个
auto groups = ranges::view::group_by(rng, bin_op)
| ranges::to_vector
| ranges::action::transform([] (auto r) { return r | ranges::to_vector; };
以及
auto groups = ranges::view::group_by(rng, bin_op)
| ranges::to_vector
| ranges::action::transform([] (auto r) { return std::vector<T>{} | ranges::action::push_back; };
因为看起来range :: action :: transform()在这种情况下返回void并且"传递给action :: transform的函数的结果类型必须可写回源范围",因此不起作用.
那么如何将范围范围转换为矢量矢量？
注意:对不好的标签很抱歉,但我找不到范围/ range-ts/ranges-v3标签,我不允许创建一个标签,也不能在标题中使用它.
我沉迷于一些早期的星期天 C++20 恶作剧，在玩 gcc/clang 主干概念时，我偶然发现了一个我没有看到优雅解决方案的问题。考虑这个代码：
template <typename T>
concept floating_point = std::is_floating_point_v<std::decay_t<T>>;
template <typename T>
concept indexable = requires(T v)
{
{v[0]} -> floating_point;
{v[1]} -> floating_point;
{v[2]} -> floating_point;
};
template <typename T>
concept func_indexable = requires(T v)
{
{v.x()} -> floating_point;
{v.y()} -> floating_point;
{v.z()} -> floating_point;
};
template <typename T>
concept name_indexable = requires(T v)
{
{v.x} -> floating_point;
{v.y} -> floating_point;
{v.z} -> floating_point;
};
template <typename T>
concept only_name_indexable = name_indexable<T> && !indexable<T>;
template <typename …我正在尝试为元组编写转换函数,但是我发现的所有示例都将函数应用于通过引用传递的元组或使用非一元函数.
但是,我希望有类似的东西
std::tuple<float, int> t(3.f, 2);
// returns std::tuple<bool, bool>:
auto r1 = transform(t, [] (auto v) { return v > decltype(v)(2); });
// returns std::tuple<float, int>:
auto r2 = transform(t, [] (auto v) { return v + decltype(v)(1); });
我得到的问题是:是否有可能确定将一元函数应用于每个元组元素的结果类型？
在建议的 C++20 (The One) Ranges TS 中，建议将视图转换为 std::vector 的方法是什么？
以下代码无法编译：
int
main() {
std::vector<float> values = {1.0, 2.0, 3.0, 4.0, 5.2, 6.0, 7.0, 8.0, 9.0};
//fmt::print("{}\n", std::experimental::ranges::views::filter(values, [] (float v) { return v < 5.f; }));
std::vector<float> foo = vw::filter(values, [] (float v) { return v < 5.f; });
fmt::print("{}\n", foo);
}
有错误
../src/view.cpp:19:40: error: conversion from ‘std::experimental::ranges::v1::filter_view<std::experimental::ranges::v1::ref_view<std::vector<float> >, main()::<lambda(float)> >’ to non-scalar type ‘std::vector<float>’ requested
std::vector<float> foo = vw::filter(values, [] (float v) { return v < 5.f; });
（由于某些 …
假设我为STL元组(元组,对)以及STL序列(向量,列表,双端队列)编写了通用映射函数.现在我想编写一个全局map函数,在给定输入类型的情况下调用相应的特殊函数.
我有类似的东西
template <typename... Ts>
struct mappable {
static constexpr bool is_instance = false;
};
template <typename... Tuples, typename = require<all<is_stl_tuple, Tuples...>::value>>
struct mappable<Tuples...> {
template <typename Func>
auto map(Func&& f, Tuples&&... ts) {
return tuple::map(std::forward<Func>(f), ts...);
}
static constexpr bool is_instance = true;
};
template <typename... Sequences, typename = require<all<is_stl_sequence, Sequences...>::value>>
struct mappable<Sequences...> {
template <typename Func>
auto map(Func&& f, Sequences&&... seqs) {
return sequence::map(std::forward<Func>(f), seqs...);
}
static constexpr bool is_instance = true;
};
template <typename Func, typename... Ts> …为了学习关于可变参数模板的一两件事,我偶然发现了这个(希望不是那个实际的)问题.我有以下示例代码:
#include <utility>
#include <tuple>
#include <iostream>
template <typename... Args>
auto args(Args&&... args) {
return std::make_tuple(std::forward<Args>(args)...);
}
template <class C, class TupleArgs, std::size_t... Indices>
C construct_class_unpacked_(TupleArgs&& args, std::index_sequence<Indices...>) {
return C(std::get<Indices>(std::forward<TupleArgs>(args))...);
}
template <class C, typename TupleArgs>
C construct(TupleArgs&& args) {
return construct_class_unpacked_<C>(std::forward<TupleArgs>(args), std::make_index_sequence<std::tuple_size<typename std::decay<TupleArgs>::type>::value>());
}
struct Root {
Root(int l) : l_(l) {
}
protected:
Root() : l_(-2) {}
public:
int l_;
};
struct A : public virtual Root {
A(int i, float f) : i_(i), f_(f) {}
int …我有看起来像这样的代码：
DataAssociator::Impl::Impl(const VoxelHasherSettings& settings_voxelhasher,
const CameraSettings& settings_camera)
{
initialize(settings_camera);
}
当我将光标置于c第一个光标的上const并按+或时，<CR>我将移至下一个光标const。
但是，按d+/ d<CR>删除太多，将导致以下情况：
{
initialize(settings_camera);
}
我正在使用neovim。
预先感谢，理查德
我目前正在使用相当不错的haskell-eigen库,偶然发现了一个基本但可能是基本的问题(我对实用的haskell开发很新).
我使用他们的基本矩阵类型
data Matrix a b :: * -> * -> *
其中a表示haskell,b表示内部C类型.这是通过限制实现的
Elem a b
同
Elem Double CDouble
Elem Float CFloat
-- more for complex types...
虽然这不是我想问的问题,但我有点不明白为什么这样做.由于它显然是一种功能映射,我已经不明白为什么这被制定为等效关系,但无论如何......
我现在想要定义(作为一个简单的例子 - 我有几个)来自keys包的Key实例.例如,它定义了给定容器的索引键
type instance [] = Int
所以Key的实例是在类型* - >*上定义的.
但是由于这个要求,这不起作用:
type instance Key Matrix = (Int, Int)
我必须以某种方式使Matrix变得善良* - >*.所以(来自c ++,我会用traits类来做),我试过这个:
type family CType a where
CType Double = CDouble
CType Float = CFloat
type MatX a = Matrix a (CType a)
换句话说,我试图使用类型同义词作为实现上述功能类型映射的手段. …