C++11

To me the most interesting feature of C++11 I am aware of are lambda functions. Though, I think also the general direction taken by C++ is leading it to a very obscure path, where other languages shine since the beginning, and where the need to use C++ rather than those other languages is not clear to say the least. Differently speaking, the most interesting features could be the one programmer could use less, simply because when you need to use them in all their beauty, you are on the edge of considering sticking to another language to do the same thing.
Moreover, C++ syntax is someway cumbersome and not clean. In some cases (not so much to be worth noting, yet they jumped in my sight) it is misleading; I believe the usage of the same keyword to mean two different things is not good (C too has this flaw, e.g. the keyword static), and if the previous standard had a third meaning for it, the situation could be confusing (I am thinking about auto). Yes, it's not a hokum but it gives the impression of something too layered and hard to handle. Modern languages without a heavy heritage have less or nothing at all of this kind of flaws.

Anyway, let's see an example of folding done with the use of a lambda function.

	#include <iostream>
	#include <numeric>
	#include <vector>
	using namespace std;
	int main()
	{
	vector<int> array = {1, 2, 3, 4, 5};
	int r = accumulate(array.begin(), array.end(), 0,
	[](const int& x, const int& y) -> int { return x + y*2; });
	cout << r << endl;
	return 0;
	}

view raw lambdacpp11.cpp hosted with ❤ by GitHub

Not particularly useful, but it shows the equivalent in C++11 of what in other languages we can write. E.g.

Smalltalk

#(1 2 3 4 5) inject: 0 into: [ :x :y | x + (y*2) ].

view raw injectinto.st hosted with ❤ by GitHub

Common Lisp

(reduce (lambda (x y) (+ x (* y 2))) '(1 2 3 4 5) :initial-value 0)

view raw lambdaclisp.cl hosted with ❤ by GitHub

Haskell

foldl (\x y -> x + y*2) 0 [1, 2, 3, 4, 5]

view raw lambdafoldl.hs hosted with ❤ by GitHub

Erlang

lists:foldl(fun(Y, X) -> X + Y*2 end, 0, [1,2,3,4,5]).

view raw foldll.erl hosted with ❤ by GitHub

Perl5

	use List::Util qw(reduce);
	my $r = reduce {$a + $b * 2 } 0, 1..5;

view raw reducell.pl hosted with ❤ by GitHub

Python

reduce(lambda x, y: x + y*2, [1,2,3,4,5], 0)

view raw reducell.py hosted with ❤ by GitHub

All these snippets run effortlessly and without the need of adding other lines of code; C++ needs "boilerplate" code, though the working line is as simple as

	accumulate(array.begin(),
	array.end(), 0,
	[](const int& x, const int& y) -> int { return x + y*2; })

view raw noboilerlamb.cpp hosted with ❤ by GitHub

(note the use of -> here, which is not syntactic sugar for (*ptr_to_obj). as it is in other contexts).

It could be funny to use some of the new C++11 features; sometimes it could be even useful; but most of the time I believe it won't be a need and C++ is becoming one of the languages with a very large set of (maybe interesting) features which are even the most misunderstood, misused, or simply ignored.