auto

I can see why the auto type in C++11 improves correctness and maintainability. I've read that it can also improve performance ( Almost Always Auto by Herb Sutter), but I miss a good explanation. How can auto improve performance? Can anyone give an example? auto can aid performance by avoiding silent implicit conversions . An example I find compelling is the following. std::map<Key, Val> m; // ... for (std::pair<Key, Val> const& item : m) { // do stuff } See the bug? Here we are, thinking we're elegantly taking every item in the map by const reference and using the new range-for expression to

In C++14, why do lambda functions with a deduced return type drop references from the return type by default? IIUC, since C++14 lambda functions with a deduced return type (without an explicit trailing return type) have a return type of auto , which drops references (among other things). Why was this decision made? It seems to me like a gotcha to remove a reference when that's what your return statement returns. This behavior caused the following nasty bug for me: class Int { public: Int(int i) : m_int{i} {} int m_int; }; class C { public: C(Int obj) : m_obj{obj} {} const auto& getObj() {

C++11 标准推出了一个新的关键词 auto ，这个关键词可以通过表达式自动推断返回值的类型，这也是新标准中被各编译器厂商支持最为广泛的特性之一。利用这个关键词可以有效减少代码的长度，特别是在使用模板元编程的时候。 举个简单的例子： vector < map < int , string >> stringMapArray; // 不使用 auto 版本 vector < map < int , string >>:: iterator iter1 = stringMapArray. begin (); // 使用 auto 版本 auto iter2 = stringMapArray. begin (); 看到这样简短的式子，我再也不能忍受第一个包含大量冗余信息的式子了。所以，最近写的C++里到处都是auto，恨不得在lambda的参数列表里也用（可惜不行）。 但是物极必反，auto的滥用却使一个非常隐蔽的问题悄然出现。最近写一个正则引擎的时候，发现运行效率总是低于预期，刚开始认为是动态内存分配的问题，通过替换成内存池后发现虽然效率有所提高，但是仍然达不到要求。于是想到了性能工具，一次检查下来发现如下语句竟然占用了70%的时间： // 函数声明 set< int >& getSet(); void foo() { // 占用 70% 的时间 auto s = getSet ()

I am learning to use boost::spirit library. I took this example http://www.boost.org/doc/libs/1_56_0/libs/spirit/example/qi/num_list1.cpp and compiled it on my computer - it works fine. However if I modify it a little - if I initialize the parser itself auto parser = qi::double_ >> *(',' >> qi::double_); somewhere as global variable and pass it to phrase_parse, everything goes crazy. Here is the complete modified code (only 1 line is modified and 1 added) - http://pastebin.com/5rWS3pMt If I run the original code and pass "3.14, 3.15" to stdin, it says Parsing succeeded, but with my modified

Consider the following program: extern int x; auto x = 42; int main() { } Clang 3.5 accepts it ( live demo ), GCC 4.9 and VS2013 do not ( live demo for the former ). Who is right, and where is the correct behavior specified in the C++ Standard? There's surprisingly little in the standard about this. About all we hear about redeclaration is: [C++11: 3.1/1]: A declaration (Clause 7) may introduce one or more names into a translation unit or redeclare names introduced by previous declarations. [..] and the only relevant part of auto 's semantics: [C++11: 7.1.6.4/3]: Otherwise, the type of the

在Linux下编译C++11 #include<typeinfo> int main() { auto a=10; cout<<typeid(a).name()<<endl; //得到a的类型，只是一个字符串 return 0; } 编译需要加-std=c++11，如下例： auto C++11中引入auto第一种作用是为了自动类型推导 auto的自动类型推导，用于从初始化表达式中推断出变量的数据类型。通过auto的自动类型推导，可以大大简化我们的编程工作 auto实际上实在编译时对变量进行了类型推导，所以不会对程序的运行效率造成不良影响 另外，似乎auto并不会影响编译速度，因为编译时本来也要右侧推导然后判断与左侧是否匹配。 auto a; // 错误，auto是通过初始化表达式进行类型推导，如果没有初始化表达式，就无法确定a的类型 auto i = 1; auto d = 1.0; auto str = "Hello World"; auto ch = 'A'; auto func = less<int>(); vector<int> iv; auto ite = iv.begin(); auto p = new foo() // 对自定义类型进行类型推导 auto不光有以上的应用，它在模板中也是大显身手，比如下例这个加工产品的例子中