# C++11
**C++11** is the [ISO/IEC 14882](https://www.edgepedia.org/iso-iec-14882):2011 revision of the C++ programming language, approved by ISO on 12 August 2011 and the second major version of the language after C++98[1](https://en.cppreference.com/cpp/11). Before approval it was known as "C++0x", a name chosen because publication before 2010 had been expected; the 8 years between C++03 and C++11 have become the longest interval between versions so far, and since then C++ has updated every 3 years regularly[1](https://en.cppreference.com/cpp/11). The Final International Draft was unanimously approved by the ISO C++ committee on March 25, 2011, and formally approved by a 21-0 national vote in August 2011[2](https://www.stroustrup.com/C++11FAQ.html). C++11 is the second major version of C++ and the most important update since C++98: it added move semantics, lambdas, variadic templates, auto type deduction, a standardized memory model, and a threading library, while remaining nearly perfectly backward-compatible with C++98/03[1](https://en.cppreference.com/cpp/11) • [3](https://isocpp.org/wiki/faq/cpp11).
| Key fact | Detail |
|---|---|
| Approval | FCD approved unanimously March 25, 2011; ISO national vote 21-0 in August 2011; published 2011[2](https://www.stroustrup.com/C++11FAQ.html) |
| Development time | 8 years after C++03, the longest interval between versions; the working name "C++0x" anticipated a pre-2010 release[1](https://en.cppreference.com/cpp/11) |
| Signature features | Rvalue references and move semantics, lambdas, variadic templates, auto/decltype, initializer lists, defaulted and deleted functions[2](https://www.stroustrup.com/C++11FAQ.html) |
| Concurrency | First standardized C++ memory model (clause 1.7), atomics with memory orders, thread class, mutexes, futures[4](https://open-std.org/Jtc1/sc22/wg21/docs/papers/2011/n3242.pdf) • [5](https://www.stroustrup.com/polish-interview.pdf) |
| Dropped feature | "Concepts" removed at the Frankfurt meeting in July 2009 to protect the schedule; a formal poll put the remaining work at 3 to 4 years[6](https://herbsutter.com/2009/07/21/trip-report/) |
| First conforming compilers | GCC 4.8.1 (May 31, 2013) for the language; Clang 3.3 (June 5, 2013) as the first complete implementation including the standard library[3](https://isocpp.org/wiki/faq/cpp11) |
| Compatibility | Nearly perfectly backward-compatible with C++98/03; move semantics can make existing code faster simply by recompiling[3](https://isocpp.org/wiki/faq/cpp11) |
## History and standardization
The C++0x process was run by the ISO committee WG21, which set explicit design goals: a machine model and concurrency support (a thread ABI, futures, thread-local storage, atomics), better support for generic programming (auto, template aliases), systems programming (constexpr, std::array, generalized PODs), and library building (inline namespaces, inherited constructors, rvalue references)[2](https://www.stroustrup.com/C++11FAQ.html). The first draft for formal national comments was produced in September 2008[2](https://www.stroustrup.com/C++11FAQ.html).
**The concepts crisis.** "Concepts" was a feature designed to allow precise specification of requirements on template arguments, and it was intended as the central improvement for generic programming[2](https://www.stroustrup.com/C++11FAQ.html) • [5](https://www.stroustrup.com/polish-interview.pdf). At the [Frankfurt](https://www.edgepedia.org/frankfurt) meeting in July 2009, a formal poll of committee members put the expected additional time to reach international-standard quality at between three and four years; most members felt it was too late for major changes, and the overwhelming majority voted to remove concepts from the working paper[6](https://herbsutter.com/2009/07/21/trip-report/) • [7](https://ar5iv.labs.arxiv.org/html/1201.0027). [Bjarne Stroustrup](https://www.edgepedia.org/bjarne-stroustrup), the language's creator and a committee member, later called the removal the most disappointing event of the process, attributing the failure partly to technical difficulty and partly to committee disagreement over design ideals[5](https://www.stroustrup.com/polish-interview.pdf).
The removal itself cost time: because so much wording had to change, a second Committee Draft had to go out for public comment in Spring or Summer 2010, slipping the final schedule by about one year[8](https://listarchives.boost.org/Archives/boost/2009/07/154068.php). Even so, some contemporaries argued that removing concepts would speed the arrival of conforming compilers and ease library migration[8](https://listarchives.boost.org/Archives/boost/2009/07/154068.php). After Frankfurt the committee targeted a final ISO draft in roughly 18 months[6](https://herbsutter.com/2009/07/21/trip-report/), and the FCD was approved on March 25, 2011[2](https://www.stroustrup.com/C++11FAQ.html).
## Core language changes
**Rvalue references and move semantics.** C++11 lets a class define move constructors and move assignments that move rather than copy their argument[2](https://www.stroustrup.com/C++11FAQ.html). The mechanism rests on a new reference type, the rvalue reference, which binds to temporaries and to objects treated as rvalues. The expression `move(x)` is just a cast that means "you can treat x as an rvalue"; it performs no move itself[9](https://isocpp.org/wiki/faq/cpp11-language). Move constructors and move assignments typically take a non-const rvalue reference and usually write to their argument, since they take over its resources[9](https://isocpp.org/wiki/faq/cpp11-language). The original move-semantics proposal was N1377 by Howard E. Hinnant, Peter Dimov, and Dave Abrahams; the final rvalue-reference wording was N2118 by Howard Hinnant[9](https://isocpp.org/wiki/faq/cpp11-language). The payoff is concrete: std::vector has a move constructor in addition to the usual copy constructor, so returning a large vector by value involves no element copies[5](https://www.stroustrup.com/polish-interview.pdf). In the C++11 standard library all containers have move constructors and move assignment, and insert() and push_back() have rvalue-reference overloads, so standard containers and algorithms improve in performance without user intervention[2](https://www.stroustrup.com/C++11FAQ.html).
**Lambdas.** C++11 added lambda expressions with capture lists that specify how local names used in the body are passed: by reference with `[&]`, by value with `[=]`, selectively with `[&v]` or `[v]`, or not at all with `[]`[9](https://isocpp.org/wiki/faq/cpp11-language).
**Templates and type deduction.** Variadic templates allow functions and classes to accept an arbitrary number of template arguments, and template aliases give names to parameterized types[2](https://www.stroustrup.com/C++11FAQ.html). The keyword auto deduces a variable's type from its initializer, and decltype yields the type of an expression; both were implemented alongside inherited constructors[2](https://www.stroustrup.com/C++11FAQ.html). Practitioner consensus has singled out rvalue references and variadic templates as the two most profound improvements of C++11 over C++03[10](https://stackoverflow.com/questions/11834896/what-benefits-does-c11-bring-in-comparison-to-c03).
**Initialization and constants.** C++11 added initializer-lists and uniform initialization, allowing many objects to be initialized with brace syntax, plus defaulted and deleted function definitions[2](https://www.stroustrup.com/C++11FAQ.html).
## Concurrency and the memory model
C++11 introduced, for the first time, concurrency in the language itself through a subtle relaxed memory model[11](https://dl.acm.org/doi/10.1145/2103656.2103717). The model is defined in clause 1.7 of the working draft[4](https://open-std.org/Jtc1/sc22/wg21/docs/papers/2011/n3242.pdf). Its design goal was that programs without any un-annotated data races, and that avoid the lowest-level interface to memory, should execute in a sequentially consistent manner; early drafts compromised this goal, but the ratified language provides the guarantee[12](https://www.sigplan.org/Awards/Dissertation/2015_batty.pdf).
The library side of the package comprised a memory model devised for modern multi-core hardware, a set of types and operations supporting lock-free programming such as atomics, a thread class, mutexes, locks, and condition variables, and async() with future for higher-level concurrency[5](https://www.stroustrup.com/polish-interview.pdf).
**Memory orders.** At the top of the interface, memory_order_seq_cst can, under certain circumstances, provide sequentially consistent behavior with a substantial cost to performance, whereas accesses given memory_order_relaxed exhibit many relaxed behaviors but enable very high-performance code[12](https://www.sigplan.org/Awards/Dissertation/2015_batty.pdf). The model is deliberately relaxed so as to permit compiler optimization and to accommodate the differing relaxed-memory behaviors of mainstream multiprocessors; researchers proved the correctness of compilation schemes for the C++11 load and store concurrency primitives to Power assembly, with ideas applying also to ARM, after noting that an earlier proposal was flawed[11](https://dl.acm.org/doi/10.1145/2103656.2103717). Earlier analysis of the drafts had observed that, while the result of careful deliberation, they were not yet clear and rigorous definitions, a gap the later work closed[13](https://dl.acm.org/doi/10.1145/1926385.1926394).
## Standard library additions
The library changes follow directly from the language. Move-aware containers and rvalue-reference overloads for insert() and push_back() mean that returning large standard containers by value is efficient without manual tricks[2](https://www.stroustrup.com/C++11FAQ.html) • [5](https://www.stroustrup.com/polish-interview.pdf). The concurrency facilities, the thread class, mutexes and locks, condition variables, atomics, and async() with future, form the other major block of the new library surface[5](https://www.stroustrup.com/polish-interview.pdf).
## By the numbers
**Compiler conformance took about two years after publication.** Modulo bugs, the first fully conforming C++11 language implementation was GCC 4.8.1, released May 31, 2013, but it still lacked a conforming standard library; the first complete implementation, including both language and library, was Clang 3.3 on June 5, 2013[3](https://isocpp.org/wiki/faq/cpp11). The conformance picture was uneven before that: per the G-truc compiler matrix, GCC 4.7 reached 91% C++11 language support while GCC 4.8, Clang 3.3, and later Clang releases each reached 100%, Visual C++ 2015 reached 88%, and Intel C++ 15.0 reached 94%[14](https://www.g-truc.net/doc/C++%20Compiler%20Matrix.pdf). Concurrency lagged furthest behind: C++11 concurrency features reached 100% in GCC 4.8 and Clang 3.3, but Visual C++ 2013 stood at 92% and Visual C++ 2010 at 25%[14](https://www.g-truc.net/doc/C++%20Compiler%20Matrix.pdf). The conformance table also shows feature-by-feature adoption, with rvalue references (papers N2118/N2844) partially supported in GCC 4.3 and complete in GCC 4.5, and Microsoft's support completed in VS 2015[15](https://cppreference.com/cpp/compiler_support/11).
**Adoption has since shifted to newer standards.** Survey reporting shows the downward trends for C++11 and C++14 continuing as developers migrate to C++20 and C++23, which have the largest adoption percentages; from C++11 onward each newer standard shows significant adoption of roughly 4% per version[16](https://www.infoworld.com/article/2335793/the-state-of-the-c-plus-plus-developer-ecosystem.html). JetBrains' 2023 ecosystem report shows the same pattern for later standards: C++17 started at 12% in 2017 and reached 18% in 2018, C++20 went from 12% in 2020 to 18% in 2021, and C++23 started at 10% in 2023[17](https://blog.jetbrains.com/clion/2024/01/the-cpp-ecosystem-in-2023/).
## C++11 versus C++03 and later standards
Against C++03, C++11 is nearly perfectly backward-compatible, and its headline performance change is passive: rvalue references and move semantics will often make existing C++ code faster simply by recompiling it with a C++11 compiler, because the standard containers and algorithms gained move overloads[3](https://isocpp.org/wiki/faq/cpp11) • [2](https://www.stroustrup.com/C++11FAQ.html).
The follow-on schedule was set even at publication: plans for the minor revision C++14 were well advanced, with features already voted into the working draft and implemented, and a major revision was planned for 2017 as C++17[2](https://www.stroustrup.com/C++11FAQ.html).
Some C++11-era library features have since been deprecated and removed. Relative to C++23, C++26 removes the atomic access API for shared_ptr objects, the header and all its contents, and the convenience interfaces wstring_convert and wbuffer_convert[18](https://timsong-cpp.github.io/cppwp/diff.cpp23.depr).
## Legacy
Its move-semantics machinery remains the mechanism by which value returning and container growth stay efficient[5](https://www.stroustrup.com/polish-interview.pdf).
## References
1. [C++11, cppreference.com](https://en.cppreference.com/cpp/11)
2. [C++11 FAQ, Bjarne Stroustrup](https://www.stroustrup.com/C++11FAQ.html)
3. [C++11 Overview, Standard C++ Foundation FAQ](https://isocpp.org/wiki/faq/cpp11)
4. [N3242: Working Draft of the C++ International Standard (2011), ISO WG21](https://open-std.org/Jtc1/sc22/wg21/docs/papers/2011/n3242.pdf)
5. [Interview with Bjarne Stroustrup (~2009)](https://www.stroustrup.com/polish-interview.pdf)
6. [Trip Report: Exit Concepts, Final ISO C++ Draft in ~18 Months, Herb Sutter (2009)](https://herbsutter.com/2009/07/21/trip-report/)
7. [The C++0x "Concepts" Effort](https://ar5iv.labs.arxiv.org/html/1201.0027)
8. [Report from Frankfurt committee meeting, Boost mailing list (July 2009)](https://listarchives.boost.org/Archives/boost/2009/07/154068.php)
9. [C++11 Language Extensions, General Features, C++ FAQ](https://isocpp.org/wiki/faq/cpp11-language)
10. [What benefits does C++11 bring in comparison to C++03? Stack Overflow](https://stackoverflow.com/questions/11834896/what-benefits-does-c11-bring-in-comparison-to-c03)
11. [Clarifying and compiling C/C++ concurrency, ACM POPL 2012](https://dl.acm.org/doi/10.1145/2103656.2103717)
12. [Mark Batty PhD dissertation on the C/C++11 memory model, SIGPLAN](https://www.sigplan.org/Awards/Dissertation/2015_batty.pdf)
13. [Mathematizing C++ concurrency, ACM POPL 2011](https://dl.acm.org/doi/10.1145/1926385.1926394)
14. [C++ Compiler Matrix, G-truc](https://www.g-truc.net/doc/C++%20Compiler%20Matrix.pdf)
15. [Compiler support for C++11, cppreference.com](https://cppreference.com/cpp/compiler_support/11)
16. [The state of the C++ developer ecosystem, InfoWorld](https://www.infoworld.com/article/2335793/the-state-of-the-c-plus-plus-developer-ecosystem.html)
17. [The C++ Ecosystem in 2023, JetBrains](https://blog.jetbrains.com/clion/2024/01/the-cpp-ecosystem-in-2023/)
18. [[diff.cpp23.depr] C++26 removals, annotated standard draft](https://timsong-cpp.github.io/cppwp/diff.cpp23.depr)
---
*Topic: Encyclopedia › Technology and the built world › Computing and digital systems › Software and programming › Programming languages › Individual programming languages › C-family and imperative languages*
*Initially written Sep 17, 2026 · Reviewed: Oct 15, 2026 · Edited: Oct 15, 2026 · Last review: Oct 15, 2026*
*Copyright 2026 EdgeChat AI, a subsidiary of Biostate AI.*
License: Edgepedia Community License 1.0, https://www.edgepedia.org/edgepedia/license