Long time no write…

Wednesday, April 2, 2014

It's been a busy period, the busiest since we established CodeValue. A week ago, my son asked me, "daddy, when will you come home not for doing more work?" Finally, I have a good answer! I am at Newark airport heading to San Francisco to Microsoft Build Conference and on Friday, my family will join me for a family vacation in Hawaii. In the last few months, I have been doing software architecture for two complex and large applications. Besides that, I delivered couple of architecture lectures and last week I gave an Advanced C++ 11/14 course. ...
no comments

Introduction to C++ 11 Series – Part 10, Ranged-Based for-Loops

Tuesday, April 9, 2013

Yes, this is post #10 in the C++ 11 series. The last post was long and complicated. In this post, I would like to write about something simpler - Ranged base loops. Ranged Based Loops, are like the C# foreach loop. The idea is to simplify iteration syntax on containers that have a beginning, an ending, and a forward iterator. Suppose we have this vector: vector<int> v; for (int i = 1; i <= 10; ++i)        v.push_back(i);   To iterate through the vector elements, use: for (auto i: v)       ...

Introduction to C++ 11 Series – Part 9, R-Value, L-Value, Move Semantics and Perfect Forwarding

Wednesday, April 3, 2013

Take a deep breath; this is a long post about one of the most important and most complex features of C++ 11. One of the most performance-boost features of C++ 11 is the new move semantics addition to the language. This feature is based on a new reference – an R-Value reference. In this post, I am going to explain what R-Value (and L-Value) is, why we need it, and how we can use it to enable move constructor & move assignment operator. We will also see the std::move function and talk about perfect forwarding and the std::forward...

Introduction to C++ 11 Series – Part 8, Lambda Expression or Functions

Monday, April 1, 2013

One of the most important features of C++ 11 is the addition of Lambda, an inline function mechanism (and a closure). Motivation The first motivation is to make this a valid C++ code: (){}(); There are many reasons to use lambda and functional programing; for example, STL algorithms use function or functor objects. STL <functional> provides a set of functors such as plus, minus, less, equal_to, etc. Most of these functors are binary functions, i.e. they take two parameters. To use a predefined binary functor in an STL algorithm, you need to...

Introduction to C++ 11 Series – Part 7, decltype, auto (again) and Trailing Return Types

Thursday, March 28, 2013

There is a joke, were a guy asks his friend, “Do you know what this is?” Doing some sort of wave shape movement with his hand. When his friend answers, “I don’t know”, the guy replies, “I don’t know either, but here comes another one like this!” decltype is, like the joke says, “another one like this”. It provides a way to use the type of an expression in any place that a type can be used: Declare a variable where the type of a given expression defines its type. Declare...

Introduction to C++ 11 Series – Part 6, auto – an old keyword with new meaning

Wednesday, March 27, 2013

Originally, auto declares a variable in the automatic storage, which is also the default behavior. This is still the behavior of the C language. In C++ 11, auto declares a variable, whose type is deduced from the initialization expression. If you are familiar with the C# var keyword, auto is almost the same. The main difference is that modifiers such as const, &, *, **, &&, static, and volatile can be added to the auto to enhance type declaration. auto is a productivity feature, it lets you write code faster. auto is also an abstraction enhancer; you...

Introduction to C++ 11 Series – Part 5, Copying & Re-throwing exceptions

Monday, March 25, 2013

Many of the new features of C++ 11 came from a real need, not just to make the language more productive but also to enable real-life scenarios. The ability to catch exception in one place in runtime environment and to re-throw it later came from the need to provide a better concurrency support in the language and libraries. C++ 11 has many new concurrent abilities that I will talk about in future posts, but now let us just say that we have, in standard C++, the ability to create and use threads. In order to understand why we need...

Introduction to C++ 11 Series – Part 4, Strongly Typed and Scoped enums

Sunday, March 24, 2013

If you are familiar with C#/.NET enums, you know how safer and easier it is to have scoped enums. Like C#, the new C++ enums are scoped, and you can choose the underlined integral type for the enum.   Old C++ enum:   enum old_enum {        old_value };   The new syntax: (similar to the C# syntax)   enum newer_enum : unsigned long long {        newer_value = ~(unsigned long long)0 };   The new enum provides: ...

Introduction to C++ 11 Series – Part 3, Local & Unnamed Types as Template Arguments

Saturday, March 23, 2013

In this post, I am going to write about a new feature, that your response might be “Ha! I didn’t know I can do that”. The old C++ standard says that local types, unnamed types and in general, types with no linkage, shall not be used as template arguments. In C++ 11 this has been solved: local types have the same linkage as their enclosing function Unnamed types have the same linkage they would have if they were named To show the change look at this code: ...

Introduction to C++ 11 Series – Part 2, the nullptr

Friday, March 22, 2013

nullptr is a real NULL pointer. Look at this sample: void nullptr_overload(int i) { cout << "int" << endl; } void nullptr_overload(int *p) { cout << "int *" << endl; } void main() {       nullptr_overload(0);       nullptr_overload(NULL);       nullptr_overload(nullptr); } Can you guess the result? The new nullptr is not another representation of 0 (zero) but it is an instance of a new type. Here are some facts: • nullptr is a reserved keyword for a constant (rvalue) of type std::nullptr_t ...