Tag: c ++ 11

对n个第一个元素已经sorting的向量进行sorting？

考虑N元素的std::vector v ，并且认为n第一个元素已经被sorting， n < N ，其中(Nn)/N非常小： 有一个聪明的方法使用STLalgorithmsorting这个向量比完整的std::sort(std::begin(v), std::end(v))更快吗？ 编辑：澄清：（Nn）未分类的元素应插入在已sorting的n个第一个元素内的正确位置。 EDIT2：奖金问题：以及如何findn？ （对应于第一个未分类的元素）

C ++ 11 std :: to_string（double） – 没有尾随零

今天我尝试了一些C ++ 11 STL的新function，并遇到了std::to_string 。 可爱的，可爱的一套function。 创build一个stringstream对象只需要进行一次双string转换对我来说似乎有点过分，所以我很高兴我们现在可以做这样的事情： std::cout << std::to_string(0.33) << std::endl; 结果？ 0.330000 我不完全满足于此。 有没有办法告诉std::to_string省略尾部的零？ 我search了互联网，但据我所见，该函数只有一个参数（要转换的值）。 回到过去，用stringstreams，你可以设置stream的宽度，但我宁愿不转换回来。 任何人遇到此问题之前/有一个解决scheme？ 一些StackOverflowsearch没有任何结果。 （一个C + + 11 STL参考： http : //en.cppreference.com/w/cpp/string/basic_string/to_string ）

为什么原始函数和用户定义的types在从函数返回为“const”时的行为不同？

#include <iostream> using namespace std; template<typename T> void f(T&&) { cout << "f(T&&)" << endl; } template<typename T> void f(const T&&) { cout << "f(const T&&)" << endl; } struct A {}; const A g1() { return {}; } const int g2() { return {}; } int main() { f(g1()); // outputs "f(const T&&)" as […]

为什么std :: equal_to有用？

C ++标准库提供了std::equal_to 。 这个函数对象默认调用Ttypes的operator== 。 使用std::equal_to什么好处？ 你能否提供一个std::equal_to有用的例子？

用可变模板扩展

以下3个gunfunction的区别是什么？ template <class… Ts> void fun(Ts… vs) { gun(A<Ts…>::hun(vs)…); gun(A<Ts…>::hun(vs…)); gun(A<Ts>::hun(vs)…); } 我对使用一个具体例子解释这三个调用的答案感兴趣。

C ++ 11和缺乏多态lambdaexpression式 – 为什么？

我一直在审查C ++ 11标准的草案版本。 特别是关于lambda的章节，我对于不引入多态lambdaexpression式的理由感到困惑。 例如，在100001种方法中，可以使用多态lambdaexpression式，我希望我们可以使用如下的代码： template<typename Container> void foo(Container c) { for_each(c.begin(), c.end(), [](T& t) { ++t; }); } 原因是什么： 委员会是否耗尽了时间？ 那个多态的lambdas太难实现了？ 或者也许他们被视为PTB不需要？ 注意：请记住上面的例子不是唯一的，它只是作为代码types的指南。 仅仅专注于为上述代码提供解决方法的答案将不被视为有效！ 相关资料： 用于C ++的Lambdaexpression式和闭包 （文档编号N1968 = 06-0038） lambda函数可以模板化吗？

使相同的C ++types别名不兼容

我使用两种不同types的信息std::vector<int> 。 我想确保我不会不小心混合这两种用途。 总之，我想要这样的一段代码失败： #include <vector> using A = std::vector<int>; using B = std::vector<int>; void fa(const A&); void fb(const B&); void fun() { A ax; B bx; fa(bx); fb(ax); } 即使fa预期typesA的参数，此代码编译。 显然， A和B是相同的。 什么是使这个代码正确编译的最简单的方法： fa(ax); fb(bx); 并使此代码失败： fa(bx); fb(ax); 当然，我可以在另一个类中包装std::vector<int> ，但是我需要重写它的接口。 另外，我可以inheritancestd::vector<int> ，但是这经常是不鼓励的。 总之，我需要两个不兼容的std::vector<int> 。 编辑 有人build议Strong typedefs可以解决这个问题。 这只是部分正确的。 如果我使用BOOST_STRONG_TYPEDEF(std::vector<int>, A) ，我需要添加一些烦人的强制转换。 例如，而不是 A ax{1,3,5}; […]

std :: string和string文字不一致

我在C ++ 0x中发现了std::string和string文字之间令人不安的不一致： #include <iostream> #include <string> int main() { int i = 0; for (auto e : "hello") ++i; std::cout << "Number of elements: " << i << '\n'; i = 0; for (auto e : std::string("hello")) ++i; std::cout << "Number of elements: " << i << '\n'; return 0; } 输出是： Number of […]

避免构造函数中的const引用和右值引用的指数增长

我正在为一个机器学习库编写一些模板类，而且我很多时候都面临着这个问题。 我主要使用策略模式，其中类接收作为不同function的模板参数策略，例如： template <class Loss, class Optimizer> class LinearClassifier { … } 问题在于构造函数。 随着策略数量（模板参数）的增长，const引用和rvalue引用的组合指数级增长。 在前面的例子中： LinearClassifier(const Loss& loss, const Optimizer& optimizer) : _loss(loss), _optimizer(optimizer) {} LinearClassifier(Loss&& loss, const Optimizer& optimizer) : _loss(std::move(loss)), _optimizer(optimizer) {} LinearClassifier(const Loss& loss, Optimizer&& optimizer) : _loss(loss), _optimizer(std::move(optimizer)) {} LinearClassifier(Loss&& loss, Optimizer&& optimizer) : _loss(std::move(loss)), _optimizer(std::move(optimizer)) {} 有没有办法避免这种情况？

在lambda函数中使用auto

#include <vector> #include <algorithm> void foo( int ) { } int main() { std::vector< int > v( { 1,2,3 } ); std::for_each( v.begin(), v.end(), []( auto it ) { foo( it+5 ); } ); } 编译时，上面的例子会像这样启动错误输出： h4.cpp: In function 'int main()': h4.cpp:13:47: error: parameter declared 'auto' h4.cpp: In lambda function: h4.cpp:13:59: error: 'it' was not […]