{"id":160,"date":"2009-02-22T04:48:19","date_gmt":"2009-02-22T02:48:19","guid":{"rendered":"http:\/\/mariusbancila.ro\/blog\/?p=160"},"modified":"2009-02-25T08:30:09","modified_gmt":"2009-02-25T06:30:09","slug":"type-inference-in-c","status":"publish","type":"post","link":"https:\/\/mariusbancila.ro\/blog\/2009\/02\/22\/type-inference-in-c\/","title":{"rendered":"Type inference in C++"},"content":{"rendered":"

The new C++0x standard provides support for type inference. The auto<\/b><\/font> keyword that was doing nothing in C++ was given a new meaning: a placeholder for a type inferred by the compiler. For those familiar with C#’s var<\/b><\/font> keyword, this is basically the same.<\/p>\n

Here is a comparison between auto<\/b><\/font> in C++ and var<\/b><\/font> in C#.<\/p>\n\n\n\n
C++<\/th>\nC#<\/th>\n<\/tr>\n
\n
\r\nint _tmain(int argc, _TCHAR* argv[])\r\n{\r\n   auto i = 42;\r\n   auto s = \"Hello world!\";\r\n   auto d = 12.50;\r\n   auto l = [](int n) {return n * n;};\r\n\r\n   cout << \"i = \" << i << endl;\r\n   cout << \"s = \" << s << endl;\r\n   cout << \"d = \" << d << endl;\r\n   cout << \"l(i) = \" << l(i) << endl;\r\n\r\n   return 0;\r\n}\r\n<\/pre>\n<\/td>\n
\n
\r\nclass Program\r\n{\r\n   static void Main(string[] args)\r\n   {\r\n      var i = 42;\r\n      var s = \"hello world\";\r\n      var d = 12.50;\r\n      \/\/var l = (n) => n * n; \/\/ error CS0815\r\n\r\n      Console.WriteLine(\"i = {0}\", i);\r\n      Console.WriteLine(\"s = {0}\", s);\r\n      Console.WriteLine(\"d = {0}\", d);\r\n   }\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/table>\n
with the output<\/p>\n\n\n\n
C++<\/th>\nC#<\/th>\n<\/tr>\n
\n
\r\ni = 42\r\ns = Hello world!\r\nd = 12.5\r\nl(i) = 1764\r\n<\/pre>\n<\/td>\n
\n
\r\ni = 42\r\ns = Hello world!\r\nd = 12.5\r\n\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/table>\n
As you can see, the use is very similar, except that in C++ you can use auto for a lambda expression, while in C# you cannot. The C# compiler raises an error, CS0815, when you try to use var with an anonymous function expressions, a lambda expression, a method group expressions, or the null literal expression, because these don’t have a type.<\/p>\n
Just like with var<\/b><\/font>, you can only use auto<\/b><\/font> locally, and not as return type from a function, or parameter to a function.<\/p>\n
\r\nauto power(int n)\r\n{\r\n   return n * n;\r\n}\r\n<\/pre>\n
\r\nerror C3532: 'auto (int)': incorrect usage of 'auto'\r\n<\/pre>\n
\r\nint power(auto n)\r\n{\r\n   return n * n;\r\n}\r\n<\/pre>\n
\r\nerror C3533: 'auto': a parameter cannot have a type that contains 'auto'\r\n<\/pre>\n
While it might not be of that much help for ints or strings, using auto for instead of vector< int >::iterator, or map< string, list< string >>::const_iterator comes in handy. The auto type inference helps us write less verbose code.<\/p>\n
\r\nvector< string > words;\r\nwords.push_back(\"hello\");\r\nwords.push_back(\"world\");\r\n\r\nfor(auto it = words.begin(); it != words.end(); ++it)\r\n   cout << *it << endl;\r\n<\/pre>\n
In addition to auto<\/b><\/font>, the C++0x standard introduces a new keyword, called decltype<\/b><\/font> (think of it as ‘typeof’), that can be used to determine the type of an expression at compile time.<\/p>\n
\r\nauto i = 42;\r\ndecltype(i) i2 = 44;\r\n<\/pre>\n
However, this new keyword was not yet introduced in Visual Studio 2010 CTP. According to Stephan T. Lavavej<\/a> from the VC++ team, it might be possible to be introduced in a next CTP or beta version.<\/p>\n
\nImplementing auto doesn’t implement decltype (C++0x’s name for what was previously called typeof) for free.<\/p>\n
Paraphrasing our libraries and compiler front-end program manager Damien Watkins, the CTP is only the first look at our VC10 functionality and there is definitely more to come. We understand that certain features “go together”, and that adding complementary features is a good thing in general. As always, customer feedback is a vital resource in forming our plans.\n<\/p><\/blockquote>\n","protected":false},"excerpt":{"rendered":"
The new C++0x standard provides support for type inference. The auto keyword that was doing nothing in C++ was given a new meaning: a placeholder for a type inferred by the compiler. For those familiar with C#’s var keyword, this is basically the same. Here is a comparison between auto in C++ and var in … Read more<\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_uag_custom_page_level_css":"","advgb_blocks_editor_width":"","advgb_blocks_columns_visual_guide":"","_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2},"jetpack_post_was_ever_published":false},"categories":[11,7,20,10],"tags":[75,451,73,90,78,77,74,76,89],"class_list":["post-160","post","type-post","status-publish","format-standard","hentry","category-csharp","category-c","category-ctps-betas","category-visual-studio","tag-auto","tag-c","tag-c0x","tag-ctp","tag-decltype","tag-inference","tag-standard","tag-var","tag-vs2010"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t