c++14 相关问题

如何在编译时获取 C++ 表达式的类型（即 constexpr'ly）？

我想在编译时使用类型的名称。例如，假设我写了： constexpr size_t my_strlen(const char* s) { const char* cp = s; while(*cp != ' ') { cp++...

为什么这段简单的代码需要异常处理

我们目前正在开发一个嵌入式系统，其中无法使用 C++ 异常，因此在编译器/链接器设置中禁用了对它们的支持。在此项目中，我们遇到 IAR 链接器错误...

测试类型是否是分配器的正确方法是什么？

在 SFINAE 上下文中编写 allocator_traits::value_type 似乎是测试类型 T 是否实际上是分配器的可行方法。然而，这并不是特别优雅，我一直...

boost::flyweights::intermodule_holder 初始化失败，出现 interprocess_exception 且权限被拒绝

我不知道为什么会失败。 Shared_memory_object 应该是唯一的，因为它只能从同一进程内访问。 当前目录是可写的，$TMPDIR 也是可写的，/tmp/ 也是可写的 ...

如何从模板函数中打印调用函数的行号？

我正在实现一个日志功能，它会记录代码的行号。代码片段如下： #包括 使用命名空间 std； char m_buffer[500]; 模板<

C++20 'char8_t' 与我们旧的 'char' 相同吗？

在CPP参考文档中， 我注意到 char 字符类型足够大，可以表示任何 UTF-8 八位 代码单元 (C++14 起) 对于 char8_t 输入 UTF-8 字符

无缝使用具有不同比较器的地图

我使用别名来引用两个地图之一： 地图＆map_alias = use_map_a？地图a：地图b； 但随后更改了map_b以使用std::greater作为其比较器（而不是defa...

无缝使用具有不同比较器的地图

我使用别名来引用两个地图之一： 地图＆map_alias = use_map_a？地图a：地图b； 但随后更改了map_b以使用std::greater作为其比较器（而不是defa...

在前向声明中自动推导返回类型并与旧函数语法混合

简介 在 C++11 中，可以声明一个函数，例如 自动 times2(double num) -> double; // A 并将其定义为 double times2(double num) { // B 返回数字*2； } A、B 对也可以是

将参数包转换为向量

我试图理解 C++ 中的可变参数模板，但我迷失在以下示例中：想象一个函数 foo(T, T, T, T) ，它接受相同类型 T 的可变参数数量并进行转换

如果我使用 2 作为输入，代码将不会继续

如果我为 std::cin >> menu; 输入数字 2，则 std::cin >> menu; 之后的代码不会执行。 一开始，我认为问题出在函数上，但代码甚至没有转到开关（...

C++ STL 列表中派生类对象的多态行为

我将基类和派生类（Account、StudentAccount、EmployeeAccount）的对象存储在 STL 列表中，并使用 STL 迭代器处理它们。对象的动态多态行为并不...

在地图中添加指向地图中键的指针

静态 std::mapnid; pnode* ptrof(pnode &pn) { auto r = nid.insert( {pn, nullptr} ); if (r.second) { nid[pn] = &(r.first->first); ...

C++ 模板、链接器错误和设计模式

请注意：此代码可能看起来过于复杂，或者引发有关 Convert 函数如何执行的进一步问题，但我故意只展示一个非常小的示例和

为什么 constexpr 函数中的参数不是常量表达式？

您能解释一下为什么这段代码无法编译吗？ // 源.cpp constexpr const char* func(const char* s) { return s;} constexpr bool find(const char *param) { constexpr const char* 结果...

如何推断 std::array 的大小？

在以下代码中： 模板 int b(int q, const std::array& 类型) { 整数 r = q； for (int t : 类型) { r = r + t； } 返回 r； } 整数...

参数数量在编译时确定的 Lambda 函数

我想声明一个具有 N 个参数的 lambda 函数，其中 N 是模板参数。就像是... 模板 A类{ 标准::函数 我想声明一个具有 N 个参数的 lambda 函数，其中 N 是模板参数。类似... template <int N> class A { std::function<void (double, ..., double)> func; // exactly n inputs }; 我想不出用元函数范例来做到这一点的方法。 您可以使用嵌套的 typedef n_ary_function 编写模板 type。该类型可以如下使用： template <int N> class A { typename n_ary_function<N, double>::type func; }; 以下代码片段包含n_ary_function的定义： template <std::size_t N, typename Type, typename ...Types> struct n_ary_function { using type = typename n_ary_function<N - 1, Type, Type, Types...>::type; }; template <typename Type, typename ...Types> struct n_ary_function<0, Type, Types...> { using type = std::function<void(Types...)>; }; 元template采用模板、计数和类型，并使用类型的N副本调用模板： template<template<class...>class target, unsigned N, class T, class... Ts> struct repeat_type_N: repeat_type_N<target, N-1, T, T, Ts...> {}; template<template<class...>class target, class T, class... Ts> struct repeat_type_N<target, 0, T, Ts...> { typedef target<Ts...> type; }; template<template<class...>class target, unsigned N, class T> using repeat_type_N_times = typename repeat_type_N<target, N, T>::type; 现在，我们使用它： template<typename... Ts> using operation=void(Ts...); template<unsigned N, class T> using N_ary_op = repeat_type_N_times< operation, N, T >; template<unsigned N> using N_double_func = N_ary_op<N,double>; 我们测试一下： void three_doubles(double, double, double) {} int main() { N_double_func<3>* ptr = three_doubles; std::function< N_double_func<3> > f = three_doubles; } 并获胜。 您到底使用double, double, double做什么完全取决于您在上述系统中的情况。例如，您可以使用 lambda 来初始化 std::function。 您可以将 double, double, double 打包到 template<class...>struct type_list{}; 中，这样您就可以将其作为一个参数传递给另一个 template，然后专门对其进行解包。 A repeat_type 对于大 N 具有较少的递归： // package for types. The typedef saves characters later, and is a common pattern in my packages: template<class...>struct types{typedef types type;}; // Takes a target and a `types`, and applies it. Note that the base has no implementation // which leads to errors if you pass a non-`types<>` as the second argument: template<template<class...>class target, class types> struct apply_types; template<template<class...>class target, class... Ts> struct apply_types<target, types<Ts...>>{ typedef target<Ts...> type; }; // alias boilerplate: template<template<class...>class target, class types> using apply_types_t=typename apply_types<target,types>::type; // divide and conquer, recursively: template<unsigned N, class T, class Types=types<>> struct make_types:make_types< (N+1)/2, T, typename make_types<N/2, T, Types>::type > {}; // terminate recursion at 0 and 1: template<class T, class... Types> struct make_types<1, T, types<Types...>>:types<T,Types...> {}; template<class T, class Types> struct make_types<0, T, Types>:Types{}; // alias boilerplate: template<unsigned N, class T> using make_types_t=typename make_types<N,T>::type; // all of the above reduces `repeat_type_N_t` to a one-liner: template<template<class...>class target, unsigned N, class T> using repeat_type_N_times = apply_types_t<target, make_types_t<N,T>>; 对于大型N，上述可以显着减少编译时间，并处理template堆栈溢出。 您不能直接执行此操作。 你可以做这样的事情 template <unsigned N> class UniformTuple; template <> class UniformTuple <0> { }; template <unsigned N> class UniformTuple : public UniformTuple <N-1> { public: template <typename... Args> UniformTuple (double arg, Args... args) : UniformTuple <N-1> (args...) , m_value (arg) { } private: double m_value; }; template <int N> class A { std :: function <void (const UniformTuple <N> &)> func; }; 为了完整起见，这是一个不使用递归的解决方案： template <class Ret, class Arg, class Idx> struct n_ary_function_; template <class Ret, class Arg, std::size_t... Idx> struct n_ary_function_<Ret, Arg, std::index_sequence<Idx...>> { template <class T, std::size_t> using id = T; using type = std::function<Ret(id<Arg, Idx>...)>; }; template <class Ret, class Arg, std::size_t N> using n_ary_function = typename n_ary_function_< Ret, Arg, std::make_index_sequence<N> >::type; 在 Coliru 上观看直播 NoSid 的解决方案非常有创意（本质上是一一“追加”类型）。我编写的另一个解决方案可能需要更少的脑力劳动，如下所示使用 std::index_sequence （这是创建未知大小的参数包的一种非常自然的方法）： #include <utility> #include <functional> #include <type_traits> template<typename T, long U> struct reduce { using type = T; }; template<typename U, typename IndexSequence> struct FunctionHolderImpl; template<typename U, long ... Indices> struct FunctionHolderImpl<U, std::index_sequence<Indices...>> { using value = std::function<void(typename reduce<U, Indices>::type...)>; }; template<long N> struct FunctionHolder { using func = FunctionHolderImpl<double, std::make_index_sequence<N>>::value; };

可重用::testing::gtest中的值生成器

我有一个软件（c++），它通过 googletest 进行了过度测试。 有很多 INSTANTIATE_TEST_SUITE_P 调用。 有一个我想重用的特定值生成器，某些东西......

寻找一种在 C++ 中计算某些值的有效方法[已关闭]

我正在用C++编写代码。我有一些向量，现在我使用 for 循环来计算我需要的向量。但是，事实证明这是非常耗时的，特别是当向量的大小是相对的时......

有理由不使用最新的C++标准吗？

我发现IDE中的默认标准通常不是最新发布的标准，甚至不是IDE中最新的标准。 例如 JetBrains 的 Clion 有 C++20 和 C++17，但默认...