Tag: c ++ 11

何时使用大括号初始化程序？: 在C ++ 11中，我们有了初始化类的新语法，这给我们提供了大量的如何初始化variables的可能性。 { // Example 1 int b(1); int a{1}; int c = 1; int d = {1}; } { // Example 2 std::complex<double> b(3,4); std::complex<double> a{3,4}; std::complex<double> c = {3,4}; auto d = std::complex<double>(3,4); auto e = std::complex<double>{3,4}; } { // Example 3 std::string a(3,'x'); std::string b{3,'x'}; // oops } { // Example […]

如何通过可变参数模板函数的异构参数包进行generics计算？: 前提：在玩了各种各样的模板之后，我意识到，实现任何超出微不足道的元编程任务的东西都将变得非常麻烦。特别是，我发现自己希望有一种方法来执行generics操作，比如迭代，分割，循环等 std::for_each方式，等等。在看了C ++和Beyond 2012 的Andrei Alexandrescu关于static if从C语言中借用一个构造）的愿望之后，我感觉到某种static for也会变得方便 – 我感觉更多这些static结构可以带来好处。所以我开始想知道是否有一种方法来实现类似于 variadic模板函数（伪代码）的参数包： template<typename… Ts> void my_function(Ts&&… args) { static for (int i = 0; i < sizeof…(args); i++) // PSEUDO-CODE! { foo(nth_value_of<i>(args)); } } 在编译时会翻译成这样的内容： template<typename… Ts> void my_function(Ts&&… args) { foo(nth_value_of<0>(args)); foo(nth_value_of<1>(args)); // … foo(nth_value_of<sizeof…(args) […]

C ++ 0x正则expression式在GCC: 以下代码： #include <regex> using namespace std; (snippage) regex_search(s, m, re); 在Microsoft C ++中工作，但GCC 4.4.3提供了以下错误消息： /usr/include/c++/4.4/tr1_impl/regex:2255：warning：inline function'bool std :: regex_search（_Bi_iter，_Bi_iter，std :: match_results <_Bi_iter，_Allocator>＆，const std :: basic_regex <_Ch_type，_Rx_traits >＆，std :: regex_constants :: match_flag_type）[with _Bi_iter = __gnu_cxx :: _ normal_iterator，std :: allocator>>，_Allocator = std :: allocator，std :: allocator>>>，_Ch_type = char，_Rx_traits = std :: regex_traits]'使用但从未定义当然，如果正则expression式只是GCC待办事项列表中的C ++ 0x特性之一，那么我也不会感到惊讶，但是我正在摸索的是，为什么它很高兴地采取包含指令，variables声明等等，并且只能通过函数调用（它甚至可以理解）。有什么我失踪？

什么是std :: promise？: 我很熟悉新的标准库的std::thread ， std::async和std::future组件（例如见这个答案），这很简单。然而，我不能完全掌握std::promise是什么，它在什么情况下最好使用。标准文档本身并不包含除了类纲要之外的大量信息，也不仅仅是:: thread 。有人可以给一个std::promise的情况下简短，简洁的例子，它是最习惯的解决scheme？

初始化程序列表中有多个突变是未定义的行为？: 我很好奇初始化列表和序列点。我刚才读到，初始化列表中的评估顺序是左alignment的。如果那样的话，评价点之间肯定有某种顺序点，我错了吗？所以说这是以下有效的代码？有没有什么会导致未定义的行为？ int i = 0; struct S { S(…) {} operator int() { return i; } }; int main() { i = S{++i, ++i}; } 任何和所有的回应表示赞赏。

initializer_list和模板types的扣除: 考虑一下function： template<typename T> void printme(T&& t) { for (auto i : t) std::cout << i; } 或任何其他函数期望与一个begin（）/ end（）启用types的一个参数。为什么以下是非法的？ printme({'a', 'b', 'c'}); 当所有这些都是合法的： printme(std::vector<char>({'a', 'b', 'c'})); printme(std::string("abc")); printme(std::array<char, 3> {'a', 'b', 'c'}); 我们甚至可以这样写： const auto il = {'a', 'b', 'c'}; printme(il); 要么 printme<std::initializer_list<char>>({'a', 'b', 'c'});

为什么C ++ 11的POD“标准布局”定义是这样的？: 我正在研究C ++ 11中新的轻松的POD定义（第9.7节）标准布局类是一个类：没有types非标准布局类（或这种types的数组）的非静态数据成员或引用，没有虚函数（10.3），没有虚基类（10.1），对所有非静态数据成员都具有相同的访问控制（第11章）没有非标准的布局基类，在大多数派生类中最多有一个非静态数据成员，最多有一个基类具有非静态数据成员，或者没有包含非静态数据成员的基类，没有与第一个非静态数据成员相同types的基类。我已经突出了一些让我感到惊讶的东西。如果我们容忍具有不同访问控制的数据成员，会出现什么问题呢？如果第一个数据成员也是基类，会出现什么问题呢？即 struct Foo {}; struct Good : Foo {int x; Foo y;}; struct Bad : Foo {Foo y; int x;}; 我承认这是一个奇怪的build筑，但为什么Bad应该禁止，但Good ？最后，如果不止一个组织成员有数据成员，会出现什么问题？

如何捕获一个lambdaexpression式unique_ptr？: 我已经尝试了以下内容： std::function<void ()> getAction(std::unique_ptr<MyClass> &&psomething){ //The caller given ownership of psomething return [psomething](){ psomething->do_some_thing(); //psomething is expected to be released after this point }; } 但它不编译。有任何想法吗？更新：如上所示，需要一些新的语法明确指定我们需要将所有权转移给lambda，我现在想的是下面的语法： std::function<void ()> getAction(std::unique_ptr<MyClass> psomething){ //The caller given ownership of psomething return [auto psomething=move(psomething)](){ psomething->do_some_thing(); //psomething is expected to be released after this point }; } 会不会是个好人选？ […]

在构造函数初始值设定项中初始化成员数组: class C { public: C() : arr({1,2,3}) //doesn't compile {} /* C() : arr{1,2,3} //doesn't compile either {} */ private: int arr[3]; }; 我相信原因是数组只能用=语法来初始化，即： int arr[3] = {1,3,4}; 问题我怎么做我想做的事（即，在构造函数中初始化一个数组（不分配正文中的元素））。这甚至有可能吗？ C ++ 03标准对ctor初始值设定项中的聚合（包括数组）初始化有什么特别之处吗？或者上述代码的无效是其他规则的必然结果吗？ C ++ 0x初始化列表是否解决了这个问题？ PS请不要提及向量，boost :: arrays以及它们对数组的优越性，我很清楚它们。

“想要速度？按价值传递“: 如我错了请纠正我。说我有： struct X { std::string mem_name; X(std::string name) : mem_name(std::move(name)) {} … }; struct Y { std::string mem_name; Y(const std::string &name) : mem_name(name) {} … }; 在X的ctor中， name显然是传给X的任何参数的拷贝， X调用std::string ctor来初始化mem_name ，对吗？我们称之为复制 – 然后移动X * ; 两个操作：复制，移动。在Y的ctor中， name是一个const ref，这意味着没有实际的元素副本，因为我们直接处理从Y的对象需要创build的地方传递的参数。但是，我们复制name来初始化Y mem_name ; 一个操作： COPY 。当然，它应该快很多（对我来说更可取）？在Scott Meyer的GN13演讲中（围绕时间8:10和8:56），他谈到了“想要速度？按价值传递” ，我想知道在传递参数（或string是否有任何性能差异或损失）通过参考和传递价值“为了获得速度？我意识到通过价值传递参数可能会很昂贵，特别是在处理大量数据时。也许（很明显？）我从谈话中失去了一些东西？