Let\u2019s look at some of the prominent C++11 core-language features.<\/p>\n
A\u00a0lambda expression\u00a0lets you define functions locally, at the place of the call, thereby eliminating much of the tedium and security risks that function objects incur. A lambda expression has the form:<\/p>\n
[capture](parameters)->return-type {body}<\/p>\n
The\u00a0 Suppose you want to count how many uppercase letters a string contains. Using\u00a0 It\u2019s as if you defined a function whose body is placed inside another function call. The ampersand in\u00a0[&Uppercase]<\/em>\u00a0means that the lambda body gets a reference to\u00a0Uppercase<\/em>\u00a0so it can modify it. Without the ampersand,\u00a0Uppercase<\/em>\u00a0would be passed by value. C++11 lambdas include constructs for member functions as well.<\/p>\n In C++03, you must specify the type of an object when you declare it. Yet in many cases, an object\u2019s declaration includes an initializer. C++11 takes advantage of this, letting you\u00a0declare objects without specifying their types:<\/p>\n Automatic type deduction is chiefly useful when the type of the object is verbose or when it\u2019s automatically generated (in templates). Consider:<\/p>\n Instead, you can declare the iterator like this:<\/p>\n The keyword\u00a0 C++11 offers a similar mechanism for capturing the type of an object or an expression. The new operator\u00a0 C++ has at least four different initialization notations, some of which overlap.<\/p>\n Parenthesized initialization looks like this:<\/p>\n You can also use the\u00a0 For POD aggregates, you use braces:<\/p>\n Finally, constructors use member initializers:<\/p>\n This proliferation is a fertile source for confusion, not only among novices. Worse yet, in C++03 you can\u2019t initialize POD array members and POD arrays allocated using\u00a0 With respect to containers, you can say goodbye to a long list of\u00a0 Similarly, C++11 supports in-class initialization of data members:<\/p>\n A function in the form:<\/p>\n is called a\u00a0defaulted function<\/em>. The\u00a0 The opposite of a defaulted function is a\u00a0deleted function<\/em>:<\/p>\n Deleted functions are useful for preventing object copying, among the rest. Recall that C++ automatically declares a copy constructor and an assignment operator for classes. To disable copying, declare these two special member functions\u00a0 At last, C++ has a keyword that designates a null pointer constant.\u00a0 In C++11 a constructor<\/strong> may call another constructor<\/strong> of the same class<\/strong>:<\/p>\n Constructor #2, the delegating constructor, invokes the\u00a0target constructor<\/em>\u00a0#1.<\/p>\n Reference types in C++03 can only bind to\u00a0lvalues. C++11 introduces a new category of reference types called\u00a0rvalue references<\/em>. Rvalue references can bind to rvalues, e.g.\u00a0temporary objects\u00a0and literals.<\/p>\n The primary reason for adding rvalue references is\u00a0move semantics<\/em>. Unlike traditional copying, moving means that a target object\u00a0pilfers<\/em>\u00a0the resources of the source object, leaving the source in an \u201cempty\u201d state. In certain cases where making a copy of an object is both expensive and unnecessary, a move operation can be used instead. To appreciate the performance gains of move semantics, consider string swapping. A naive implementation would look like this:<\/p>\n This is expensive. Copying a string entails the allocation of raw memory and copying the characters from the source to the target. In contrast, moving strings merely swaps two data members, without allocating memory, copying char arrays and deleting memory:<\/p>\n If you\u2019re implementing a class that supports moving, you can declare a move constructor and a move assignment operator like this:<\/p>\n The C++11 Standard Library uses move semantics extensively. Many algorithms and containers are now move-optimized.<\/p>\n C++ underwent a major facelift in 2003 in the form of the\u00a0Library Technical Report 1(TR1). TR1 included new container classes ( Unquestionably, the most important addition to C++11 from a programmer\u2019s perspective is concurrency. C++11 has a thread class that represents an execution thread,\u00a0promises and futures, which are objects that are used for synchronization in a concurrent environment, the\u00a0async()\u00a0function template for launching concurrent tasks, and the\u00a0thread_local\u00a0storage type for declaring thread-unique data. For a quick tour of the C++11 threading library, read Anthony Williams\u2019\u00a0Simpler Multithreading in C++0x<\/a>.<\/p>\n C++98 defined only one smart pointer class,\u00a0 The C++11 Standard Library defines new algorithms that mimic the set theory operations\u00a0 A new category of\u00a0 The algorithm\u00a0[]<\/tt><\/code>\u00a0construct inside a function call\u2019s argument list indicates the beginning of a lambda expression. Let\u2019s see a lambda example.<\/p>\nfor_each()<\/tt><\/code>\u00a0to traverses a char array, the following lambda expression determines whether each letter is in uppercase. For every uppercase letter it finds, the lambda expression increments\u00a0Uppercase<\/tt><\/code>, a variable defined outside the lambda expression:<\/p>\nint main()<\/tt>\r\n{<\/tt>\r\n char s[]=\"Hello World!\";<\/tt>\r\n int Uppercase = 0; \/\/modified by the lambda<\/tt>\r\n for_each(s, s+sizeof(s), [&Uppercase] (char c) {<\/tt>\r\n if (isupper(c))<\/tt>\r\n Uppercase++;<\/tt>\r\n });<\/tt>\r\n cout<< Uppercase<<\" uppercase letters in: \"<< s<<endl;<\/tt>\r\n}<\/tt><\/pre>\nAutomatic Type Deduction and\u00a0
decltype<\/code><\/h2>\nauto x=0; \/\/x has type int because 0 is int\r\nauto c='a'; \/\/char\r\nauto d=0.5; \/\/double<\/tt>\r\nauto national_debt=14400000000000LL;\/\/long long<\/tt><\/tt><\/pre>\n
void func(const vector<int> &vi)<\/tt>\r\n{<\/tt>\r\n vector<int>::const_iterator ci=vi.begin();<\/tt>\r\n}<\/tt><\/pre>\nauto ci=vi.begin();<\/tt><\/pre>\n
auto<\/tt><\/code>\u00a0isn\u2019t new; it actually dates back the pre-ANSI C era. However, C++11 has changed its meaning;\u00a0auto<\/tt><\/code>\u00a0no longer designates an object with automatic storage type. Rather, it declares an object whose type is deducible from its initializer. The old meaning of\u00a0auto<\/tt><\/code>\u00a0was removed from C++11 to avoid confusion.<\/p><\/blockquote>\ndecltype<\/tt><\/code>\u00a0takes an expression and \u201creturns\u201d its type:<\/p>\nconst vector<int> vi;\r\ntypedef decltype (vi.begin()) CIT;<\/tt>\r\nCIT another_const_iterator;<\/tt><\/pre>\n
Uniform Initialization Syntax<\/h2>\n
std::string s(\"hello\");<\/tt>\r\nint m=int(); \/\/default initialization<\/tt><\/pre>\n
=<\/tt><\/code>\u00a0notation for the same purpose in certain cases:<\/p>\nstd::string s=\"hello\";<\/tt>\r\nint x=5;<\/tt><\/pre>\n
int arr[4]={0,1,2,3};<\/tt>\r\nstruct tm today={0};<\/tt><\/pre>\nstruct S {<\/tt>\r\n int x;<\/tt>\r\n S(): x(0) {} };<\/tt><\/pre>\nnew[]<\/tt><\/code>. C++11 cleans up this mess with a uniform brace notation:<\/p>\nclass C<\/tt>\r\n{<\/tt>\r\nint a;<\/tt>\r\nint b;<\/tt>\r\npublic:<\/tt>\r\n C(int i, int j);<\/tt>\r\n};<\/tt>\r\n\r\nC c {0,0}; \/\/C++11 only. Equivalent to: C c(0,0);<\/tt>\r\n\r\nint* a = new int[3] { 1, 2, 0 }; \/C++11 only<\/tt>\r\n\r\nclass X {<\/tt>\r\n int a[4];<\/tt>\r\npublic:<\/tt>\r\n X() : a{1,2,3,4} {} \/\/C++11, member array initializer<\/tt>\r\n};<\/tt><\/pre>\npush_back()<\/tt><\/code>calls. In C++11 you can initialize containers intuitively:<\/p>\n\/\/ C++11 container initializer<\/tt>\r\nvector<string> vs={ \"first\", \"second\", \"third\"};<\/tt>\r\nmap singers =<\/tt>\r\n { {\"Lady Gaga\", \"+1 (212) 555-7890\"},<\/tt>\r\n {\"Beyonce Knowles\", \"+1 (212) 555-0987\"}};<\/tt><\/pre>\nclass C<\/tt>\r\n{<\/tt>\r\n int a=7; \/\/C++11 only<\/tt>\r\npublic:<\/tt>\r\n C();<\/tt>\r\n};<\/tt><\/pre>\nDeleted and Defaulted Functions<\/h2>\n
struct A<\/tt>\r\n{<\/tt>\r\n A()=default; \/\/C++11<\/tt>\r\n virtual ~A()=default; \/\/C++11<\/tt>\r\n};<\/tt><\/pre>\n=default;<\/tt><\/code>\u00a0part instructs the compiler to generate the default implementation for the function. Defaulted functions have two advantages: They are more efficient than manual implementations, and they rid the programmer from the chore of defining those functions manually.<\/p>\nint func()=delete;<\/tt><\/pre>\n
=delete<\/tt><\/code>:<\/p>\nstruct NoCopy<\/tt>\r\n{<\/tt>\r\n NoCopy & operator =( const NoCopy & ) = delete;<\/tt>\r\n NoCopy ( const NoCopy & ) = delete;<\/tt>\r\n};<\/tt>\r\nNoCopy a;<\/tt>\r\nNoCopy b(a); \/\/compilation error, copy ctor is deleted<\/tt><\/pre>\nnullptr<\/h2>\n
nullptr<\/code>replaces the bug-prone\u00a0NULL<\/tt><\/code>\u00a0macro and the literal 0 that have been used as null pointer substitutes for many years.\u00a0nullptr<\/tt><\/code>\u00a0is strongly-typed:<\/p>\nvoid f(int); \/\/#1<\/tt>\r\nvoid f(char *);\/\/#2<\/tt>\r\n\/\/C++03<\/tt>\r\nf(0); \/\/which f is called?<\/tt>\r\n\/\/C++11<\/tt>\r\nf(nullptr) \/\/unambiguous, calls #2<\/tt><\/pre>\n
nullptr<\/tt><\/code>\u00a0is applicable to all pointer categories, including function pointers and pointers to members:<\/p>\nconst char *pc=str.c_str(); \/\/data pointers<\/tt>\r\nif (pc!=nullptr)<\/tt>\r\n cout<<pc<<endl;<\/tt>\r\nint (A::*pmf)()=nullptr; \/\/pointer to member function<\/tt>\r\nvoid (*pmf)()=nullptr; \/\/pointer to function<\/tt><\/pre>\n
Delegating Constructors<\/h2>\n
class M \/\/C++11 delegating constructors\r\n{<\/tt>\r\n int x, y;<\/tt>\r\n char *p;<\/tt>\r\npublic:<\/tt>\r\n M(int v) : x(v), y(0), p(new char [MAX]) {} \/\/#1 target<\/tt>\r\n M(): M(0) {cout<<\"delegating ctor\"<<endl;} \/\/#2 delegating<\/tt>\r\n};<\/tt><\/pre>\nRvalue References<\/h2>\n
void naiveswap(string &a, string & b)<\/tt>\r\n{<\/tt>\r\n string temp = a;<\/tt>\r\n a=b;<\/tt>\r\n b=temp;<\/tt>\r\n}<\/tt><\/pre>\nvoid moveswapstr(string& empty, string & filled)<\/tt>\r\n{<\/tt>\r\n\/\/pseudo code, but you get the idea<\/tt>\r\n size_t sz=empty.size();<\/tt>\r\n const char *p= empty.data();<\/tt>\r\n\/\/move filled's resources to empty<\/tt>\r\n empty.setsize(filled.size());<\/tt>\r\n empty.setdata(filled.data());<\/tt>\r\n\/\/filled becomes empty<\/tt>\r\n filled.setsize(sz);<\/tt>\r\n filled.setdata(p);<\/tt>\r\n}<\/tt><\/pre>\nclass Movable<\/tt>\r\n{<\/tt>\r\nMovable (Movable&&); \/\/move constructor<\/tt>\r\nMovable&& operator=(Movable&&); \/\/move assignment operator<\/tt>\r\n};<\/tt><\/pre>\nC++11 Standard Library<\/h2>\n
unordered_set<\/tt><\/code>,\u00a0unordered_map<\/tt><\/code>,\u00a0unordered_multiset<\/tt><\/code>, and\u00a0unordered_multimap<\/tt><\/code>) and several new libraries for regular expressions, tuples, function object wrapper and more. With the approval of C++11, TR1 is officially incorporated into standard C++ standard, along with new libraries that have been added since TR1. Here are some of the C++11 Standard Library features:<\/p>\nThreading Library<\/h2>\n
New Smart Pointer Classes<\/h2>\n
auto_ptr<\/tt><\/code>, which is now deprecated. C++11 includes new smart pointer classes:\u00a0shared_ptr<\/a>\u00a0and the recently-added\u00a0unique_ptr<\/a>. Both are compatible with other Standard Library components, so you can safely store these smart pointers in standard containers and manipulate them with standard algorithms.<\/p>\nNew C++ Algorithms<\/h2>\n
all_of()<\/tt><\/code>,\u00a0any_of()<\/tt><\/code>\u00a0and\u00a0none_of()<\/tt><\/code>. The following listing applies the predicate\u00a0ispositive()<\/tt><\/code>\u00a0to the range\u00a0[first, first+n)<\/tt><\/code>\u00a0and uses\u00a0all_of()<\/tt><\/code>,\u00a0any_of()<\/tt><\/code>\u00a0and\u00a0none_of()<\/tt><\/code>\u00a0to examine the range\u2019s properties:<\/p>\n#include <algorithm><\/tt>\r\n\/\/C++11 code<\/tt>\r\n\/\/are all of the elements positive?<\/tt>\r\nall_of(first, first+n, ispositive()); \/\/false<\/tt>\r\n\/\/is there at least one positive element?<\/tt>\r\nany_of(first, first+n, ispositive());\/\/true<\/tt>\r\n\/\/ are none of the elements positive?<\/tt>\r\nnone_of(first, first+n, ispositive()); \/\/false<\/tt><\/pre>\n
copy_n<\/tt><\/code>\u00a0algorithms is also available. Using\u00a0copy_n()<\/tt><\/code>, copying an array of 5 elements to another array is a cinch:<\/p>\n#include<\/tt>\r\nint source[5]={0,12,34,50,80};<\/tt>\r\nint target[5];<\/tt>\r\n\/\/copy 5 elements from source to target<\/tt>\r\ncopy_n(source,5,target);<\/tt><\/pre>\niota()<\/tt><\/code>\u00a0creates a range of sequentially increasing values, as if by assigning an initial value to\u00a0*first<\/tt><\/code>, then incrementing that value using prefix ++. In the following listing,\u00a0iota()<\/tt><\/code>\u00a0assigns the consecutive values {10,11,12,13,14} to the array\u00a0arr<\/tt><\/code>, and {\u2018a\u2019, \u2018b\u2019, \u2018c\u2019} to the char array\u00a0c<\/tt><\/code>.<\/p>\ninclude <numeric><\/tt>\r\nint a[5]={0};<\/tt>\r\nchar c[3]={0};<\/tt>\r\niota(a, a+5, 10); \/\/changes a to {10,11,12,13,14}<\/tt>\r\niota(c, c+3, 'a'); \/\/{'a','b','c'}<\/tt><\/pre>\n