C++14

C++14. Officially known as ISO/IEC 14882:2014, it is a major revision of the C++ programming language approved by the International Organization for Standardization in December 2014. As the successor to C++11, it was developed by the ISO/IEC JTC1/SC22/WG21 committee, often referred to as the C++ Standards Committee, with significant contributions from members like Bjarne Stroustrup and Herb Sutter. The release focused on refining and completing features introduced in the previous standard, improving support for generic programming and compile-time computation, rather than introducing large, disruptive changes.

Overview

C++14 was conceived as a minor release following the major overhaul of C++11, intended to address bugs, clarify specifications, and deliver small, targeted improvements. The development process, managed under the committee's "standing document" procedures, aimed for a quicker three-year cycle compared to the lengthy development of its predecessor. Key figures like Bjarne Stroustrup and project editor Jonathan Wakely emphasized its role as a "completeness release" for C++11. The final draft standard, N4140, was published by the International Organization for Standardization in late 2014, with official ratification occurring at the WG21 meeting in Hawaii.

New language features

The language core received several enhancements to improve programmer convenience and performance. A significant addition was **generic lambdas**, allowing lambda parameters to be declared with the `auto` type specifier, greatly simplifying code used with Standard Template Library algorithms. The **`constexpr`** keyword was relaxed, permitting more complex statements like loops and variable mutations within `constexpr` functions, advancing the capabilities of compile-time programming. **Variable templates** were introduced, enabling the definition of templates that represent a family of variables or static data members. Other features included **digit separators** using single quotes (e.g., `1'000'000`) for readability, **return type deduction** for normal functions, and the **`deprecated`** attribute for marking obsolete code. The **binary literals** (e.g., `0b1010`) feature, previously available as an extension in compilers like GCC and Clang, was standardized.

New standard library features

The C++ Standard Library was extended with new utilities and specializations. The **`std::make_unique`** function template was added to the <memory> header, providing symmetry with `std::make_shared` for creating std::unique_ptr objects. The **`std::shared_timed_mutex`** and **`std::shared_lock`** were introduced in the <shared_mutex> header to support reader-writer lock patterns. For compile-time integer sequences, the **`std::integer_sequence`** and related helpers in the <utility> header facilitated template metaprogramming. The <chrono> library gained user-defined literals for time durations (e.g., `24h`, `5min`). Furthermore, many existing facilities in the Standard Template Library, such as algorithms like `std::equal` and `std::mismatch`, received additional overloads for increased flexibility and performance.

Deprecated and removed features

The standard deprecated a small set of features, signaling their potential removal in future revisions. The most notable deprecation was the **`std::gets`** function from the <cstdio> header, due to its inherent security vulnerabilities from unbounded input. The **`std::random_shuffle`** algorithm was deprecated in favor of `std::shuffle`, which requires an explicit random-number engine for better predictability and control. Features related to the obsolete **`std::bind1st`** and **`std::bind2nd`** were already removed, having been superseded by C++11's `std::bind` and lambda expressions. The specification also clarified the removal of the archaic **`register`** keyword, which had been rendered meaningless for optimizations by modern compilers like MSVC and GCC.

Compatibility with C++11

C++14 was designed to be highly compatible with C++11, maintaining almost complete source and ABI backward compatibility. Code written for C++11 typically compiled without modification under a C++14-conforming compiler such as Clang 3.4, GCC 4.9, or Visual Studio 2015. The changes were largely additive or relaxations of previous restrictions, such as the expanded `constexpr` rules. This smooth upgrade path was a deliberate goal of the C++ Standards Committee, ensuring that the ecosystem, including major projects and libraries like Boost, could adopt the new standard incrementally. The committee's subsequent work on C++17 continued this pattern of evolutionary enhancement.

Category:C++