{"id":1809,"date":"2024-06-03T17:23:00","date_gmt":"2024-06-03T17:23:00","guid":{"rendered":"https:\/\/cppdepend.com\/blog\/?p=1809"},"modified":"2024-06-12T10:18:04","modified_gmt":"2024-06-12T10:18:04","slug":"c26-is-coming-but-what-are-the-major-features-that-have-been-added-to-c-since-c11","status":"publish","type":"post","link":"https:\/\/cppdepend.com\/blog\/c26-is-coming-but-what-are-the-major-features-that-have-been-added-to-c-since-c11\/","title":{"rendered":"C++26 is coming, but what are the major features that have been added to C++ since C++11?"},"content":{"rendered":"\n

<\/h3>\n\n\n\n

Modern C++ has seen a series of significant updates starting from C++11, each bringing new features and enhancements that aim to make the language more efficient, readable, and maintainable. Here’s a brief overview of the major features introduced in each version since C++11, along with a comment on their usage:<\/p>\n\n\n\n

C++11<\/h2>\n\n\n\n

C++11 marked a significant evolution in the C++ language, introducing several powerful features that modernized and simplified C++ programming. Here are some of the most impactful features, along with examples to illustrate their usage:<\/p>\n\n\n\n\n\n\n\n

1. Auto type Deduction<\/h4>\n\n\n\n

The auto<\/code> keyword allows the compiler to automatically deduce the type of a variable from its initializer.<\/p>\n\n\n\n

auto x = 42;       \/\/ int\nauto y = 3.14;     \/\/ double\nauto s = "hello";  \/\/ const char*<\/pre><\/div>\n\n\n\n
2. Lambda Expressions<\/strong><\/h4>\n\n\n\n
Lambdas provide a concise way to define anonymous functions directly in your code.<\/p>\n\n\n\n
auto add = [](int a, int b) { return a + b; };\nint result = add(3, 4);  \/\/ result is 7<\/pre><\/div>\n\n\n\n
3. Range-based for Loops<\/strong><\/h4>\n\n\n\n
Simplifies iteration over collections like arrays, vectors, and other containers.<\/p>\n\n\n\n
std::vector<int> numbers = {1, 2, 3, 4, 5};\nfor (int n : numbers) {\n    std::cout << n << " ";\n}<\/pre><\/div>\n\n\n\n
4. Smart Pointers<\/strong><\/h4>\n\n\n\n
Introduces std::unique_ptr<\/code> and std::shared_ptr<\/code> to manage dynamic memory automatically, preventing memory leaks.<\/p>\n\n\n\n
std::unique_ptr<int> ptr(new int(10));\n\/\/ No need to delete ptr manually; it will be deleted when it goes out of scope<\/pre><\/div>\n\n\n\n
5. Move Semantics<\/strong><\/h4>\n\n\n\n
Move semantics optimize performance by allowing resources to be transferred rather than copied.<\/p>\n\n\n\n
std::vector<int> makeVector() {\n    std::vector<int> v = {1, 2, 3};\n    return v;  \/\/ Moves v rather than copying\n}\n\nstd::vector<int> v = makeVector();  \/\/ Efficient move<\/pre><\/div>\n\n\n\n
6. nullptr<\/strong><\/h4>\n\n\n\n
Replaces NULL<\/code> with nullptr<\/code> to represent null pointers more safely.<\/p>\n\n\n\n
int* p = nullptr;  \/\/ p is a null pointer<\/pre><\/div>\n\n\n\n
7. constexpr<\/strong><\/h4>\n\n\n\n
Allows for compile-time constant expressions, improving performance by performing computations at compile time.<\/p>\n\n\n\n
constexpr int square(int x) {\n    return x * x;\n}\n\nint arr[square(5)];  \/\/ Creates an array of size 25<\/pre><\/div>\n\n\n\n
8. std::thread<\/strong><\/h4>\n\n\n\n
Provides a standard way to create and manage threads, enabling concurrent programming.<\/p>\n\n\n\n
#include <thread>\n#include <iostream>\n\nvoid hello() {\n    std::cout << "Hello from thread!" << std::endl;\n}\n\nint main() {\n    std::thread t(hello);\n    t.join();  \/\/ Wait for thread to finish\n    return 0;\n}<\/pre><\/div>\n\n\n\n
9. Variadic Templates<\/strong><\/h4>\n\n\n\n
Supports templates with a variable number of arguments, making template programming more flexible.<\/p>\n\n\n\n
template<typename... Args>\nvoid print(Args... args) {\n    (std::cout << ... << args) << std::endl;  \/\/ Fold expression (C++17)\n}\n\nprint(1, 2, "three", 4.0);<\/pre><\/div>\n\n\n\n
10. Uniform Initialization<\/strong><\/h4>\n\n\n\n
Enables a consistent syntax for initializing variables and containers.<\/p>\n\n\n\n
int arr[] = {1, 2, 3};\nstd::vector<int> v = {1, 2, 3, 4, 5};\nstruct Point { int x, y; };\nPoint p = {1, 2};<\/pre><\/div>\n\n\n\n
C++14<\/h3>\n\n\n\n
C++14 built upon the foundation of C++11, introducing several important enhancements to improve code readability, flexibility, and performance. Here are the major features with examples:<\/p>\n\n\n\n
1. Generic Lambdas<\/h4>\n\n\n\n
C++14 allows the use of auto<\/code> in lambda parameter lists, making lambdas more flexible and easier to use with generic code.<\/p>\n\n\n\n
Example:<\/strong><\/p>\n\n\n\n
auto add = [](auto a, auto b) { return a + b; };\nstd::cout << add(1, 2) << std::endl; \/\/ Output: 3\nstd::cout << add(1.5, 2.3) << std::endl; \/\/ Output: 3.8<\/pre><\/div>\n\n\n\n
2. Variable Templates<\/h4>\n\n\n\n
Variable templates enable the definition of templates for variables, not just functions or classes.<\/p>\n\n\n\n
Example:<\/strong><\/p>\n\n\n\n
template<typename T>\nconstexpr T pi = T(3.1415926535897932385L);\n\nstd::cout << pi<double> << std::endl; \/\/ Output: 3.14159\nstd::cout << pi<float> << std::endl; \/\/ Output: 3.14159f<\/pre><\/div>\n\n\n\n
3. Return Type Deduction<\/h4>\n\n\n\n
C++14 allows functions to deduce their return type automatically using auto<\/code>.<\/p>\n\n\n\n
Example:<\/strong><\/p>\n\n\n\n
auto add(int a, int b) {\n    return a + b;\n}\n\nstd::cout << add(1, 2) << std::endl; \/\/ Output: 3<\/pre><\/div>\n\n\n\n
4. std::make_unique<\/h4>\n\n\n\n
This utility function simplifies the creation of std::unique_ptr<\/code> instances, making the code more readable and less error-prone.<\/p>\n\n\n\n
Example:<\/strong><\/p>\n\n\n\n
#include <memory>\n\nauto ptr = std::make_unique<int>(42);\nstd::cout << *ptr << std::endl; \/\/ Output: 42<\/pre><\/div>\n\n\n\n
5. Deprecated Attribute<\/h4>\n\n\n\n
The [[deprecated]]<\/code> attribute can be used to mark functions and variables as deprecated, generating compile-time warnings when they are used.<\/p>\n\n\n\n
Example:<\/strong><\/p>\n\n\n\n
[[deprecated("Use new_function() instead")]]\nvoid old_function() {}\n\nvoid new_function() {}\n\nint main() {\n    old_function(); \/\/ Warning: 'old_function' is deprecated: Use new_function() instead\n    new_function();\n}<\/pre><\/div>\n\n\n\n
6. Binary Literals and Digit Separators<\/h4>\n\n\n\n
C++14 introduced binary literals prefixed with 0b<\/code> or 0B<\/code> and the single quotation mark as a digit separator to improve readability of large numbers.<\/p>\n\n\n\n
Example:<\/strong><\/p>\n\n\n\n
int binary = 0b1010; \/\/ Binary literal\nint largeNumber = 1'000'000; \/\/ Digit separator\n\nstd::cout << binary << std::endl; \/\/ Output: 10\nstd::cout << largeNumber << std::endl; \/\/ Output: 1000000<\/pre><\/div>\n\n\n\n
C++17<\/h4>\n\n\n\n
C++17 brought a plethora of new features and enhancements, making the language more expressive and user-friendly. Here are some of the major additions with detailed explanations and examples:<\/p>\n\n\n\n
1.std::optional<\/h4>\n\n\n\n
std::optional<\/code> is a utility that represents a value that may or may not be present. It’s useful for functions that might not return a value.<\/p>\n\n\n\n
Example:<\/strong><\/p>\n\n\n\n
#include <optional>\n#include <iostream>\n\nstd::optional<int> find_even_number(int num) {\n    if (num % 2 == 0) return num;\n    return std::nullopt;\n}\n\nint main() {\n    auto result = find_even_number(4);\n    if (result) {\n        std::cout << "Even number: " << *result << "\\n";\n    } else {\n        std::cout << "Not an even number\\n";\n    }\n}<\/pre><\/div>\n\n\n\n
2.std::variant<\/h4>\n\n\n\n
std::variant<\/code> is a type-safe union, allowing a variable to hold one of several specified types.<\/p>\n\n\n\n
Example:<\/strong><\/p>\n\n\n\n
#include <variant>\n#include <iostream>\n\nint main() {\n    std::variant<int, float, std::string> my_variant;\n    my_variant = 10;\n    std::cout << std::get<int>(my_variant) << "\\n";\n\n    my_variant = 3.14f;\n    std::cout << std::get<float>(my_variant) << "\\n";\n\n    my_variant = "Hello";\n    std::cout << std::get<std::string>(my_variant) << "\\n";\n}<\/pre><\/div>\n\n\n\n
3.std::any<\/h4>\n\n\n\n
std::any<\/code> is a type-safe container for single values of any type. It’s useful when the type of the value is not known at compile time.<\/p>\n\n\n\n
Example:<\/strong><\/p>\n\n\n\n
#include <any>\n#include <iostream>\n\nint main() {\n    std::any my_any;\n    my_any = 42;\n    std::cout << std::any_cast<int>(my_any) << "\\n";\n\n    my_any = std::string("Hello");\n    std::cout << std::any_cast<std::string>(my_any) << "\\n";\n}<\/pre><\/div>\n\n\n\n
4. Structured Bindings<\/h4>\n\n\n\n
Structured bindings allow for unpacking tuple-like objects directly into individual variables.<\/p>\n\n\n\n
Example:<\/strong><\/p>\n\n\n\n
#include <tuple>\n#include <iostream>\n\nstd::tuple<int, float, std::string> get_data() {\n    return {1, 2.3f, "test"};\n}\n\nint main() {\n    auto [i, f, s] = get_data();\n    std::cout << "i: " << i << ", f: " << f << ", s: " << s << "\\n";\n}<\/pre><\/div>\n\n\n\n
5.if constexpr<\/h4>\n\n\n\n
if constexpr<\/code> enables compile-time conditional compilation.<\/p>\n\n\n\n
Example:<\/strong><\/p>\n\n\n\n
#include <iostream>\n\ntemplate <typename T>\nvoid print_type_info(T value) {\n    if constexpr (std::is_integral_v<T>) {\n        std::cout << "Integral type\\n";\n    } else {\n        std::cout << "Non-integral type\\n";\n    }\n}\n\nint main() {\n    print_type_info(42);\n    print_type_info(3.14);\n}<\/pre><\/div>\n\n\n\n
6. Fold Expressions<\/h4>\n\n\n\n
Fold expressions simplify the use of variadic templates by providing a concise syntax for operations on parameter packs.<\/p>\n\n\n\n
Example:<\/strong><\/p>\n\n\n\n
#include <iostream>\n\ntemplate<typename... Args>\nauto sum(Args... args) {\n    return (... + args); \/\/ fold expression\n}\n\nint main() {\n    std::cout << "Sum: " << sum(1, 2, 3, 4, 5) << "\\n";\n}<\/pre><\/div>\n\n\n\n
7. Filesystem Library<\/h4>\n\n\n\n
The <filesystem><\/code> library provides facilities for performing operations on file systems and their components.<\/p>\n\n\n\n
Example:<\/strong><\/p>\n\n\n\n
#include <filesystem>\n#include <iostream>\n\nint main() {\n    std::filesystem::path p{"example.txt"};\n    if (std::filesystem::exists(p)) {\n        std::cout << p << " exists\\n";\n    } else {\n        std::cout << p << " does not exist\\n";\n    }\n}<\/pre><\/div>\n\n\n\n
These features collectively enhance the power and flexibility of C++, making it easier to write robust, modern, and efficient code.<\/p>\n\n\n\n
C++20<\/h4>\n\n\n\n
C++20 is a milestone in the evolution of C++, bringing a host of powerful features that enhance the language’s expressiveness, safety, and performance. Here\u2019s a detailed look at the major additions with examples:<\/p>\n\n\n\n
1. Concepts<\/h4>\n\n\n\n
Concepts provide a way to specify constraints on template parameters, making templates more readable and error messages more understandable.<\/p>\n\n\n\n
#include <concepts>\n#include <iostream>\n\ntemplate <typename T>\nconcept Integral = std::is_integral_v<T>;\n\ntemplate <Integral T>\nT add(T a, T b) {\n    return a + b;\n}\n\nint main() {\n    std::cout << add(3, 4) << '\\n';  \/\/ Works\n    \/\/ std::cout << add(3.0, 4.0) << '\\n';  \/\/ Error: double doesn't satisfy Integral\n}<\/pre><\/div>\n\n\n\n
2. Ranges<\/h4>\n\n\n\n
The Ranges library introduces a new way to work with sequences of data, making code more readable and expressive.<\/p>\n\n\n\n
#include <ranges>\n#include <vector>\n#include <iostream>\n\nint main() {\n    std::vector<int> v = {1, 2, 3, 4, 5};\n    auto result = v | std::ranges::views::filter([](int n) { return n % 2 == 0; });\n\n    for (int n : result) {\n        std::cout << n << ' ';  \/\/ Output: 2 4\n    }\n}<\/pre><\/div>\n\n\n\n
3. Coroutines<\/h4>\n\n\n\n
Coroutines allow for writing asynchronous code in a sequential style, simplifying the development of concurrent applications.<\/p>\n\n\n\n
#include <coroutine>\n#include <iostream>\n\nstruct ReturnObject {\n    struct promise_type {\n        ReturnObject get_return_object() { return {}; }\n        std::suspend_never initial_suspend() { return {}; }\n        std::suspend_never final_suspend() noexcept { return {}; }\n        void unhandled_exception() {}\n        void return_void() {}\n    };\n};\n\nReturnObject foo() {\n    std::cout << "Hello ";\n    co_await std::suspend_always{};\n    std::cout << "World\\n";\n}\n\nint main() {\n    auto handle = foo();\n    handle.resume();\n    handle.resume();\n}<\/pre><\/div>\n\n\n\n
4. Modules<\/h4>\n\n\n\n
Modules provide a new way to organize and import code, improving compile times and code encapsulation.<\/p>\n\n\n\n
\/\/ my_module.ixx\nexport module my_module;\nexport int add(int a, int b) {\n    return a + b;\n}\n\n\/\/ main.cpp\nimport my_module;\n#include <iostream>\n\nint main() {\n    std::cout << add(3, 4) << '\\n';  \/\/ Output: 7\n}<\/pre><\/div>\n\n\n\n
5. Three-way Comparison (Spaceship Operator)<\/h4>\n\n\n\n
The three-way comparison operator (<=><\/code>) simplifies the implementation of comparisons and provides a consistent way to handle them.<\/p>\n\n\n\n
#include <compare>\n#include <iostream>\n\nstruct Point {\n    int x, y;\n    auto operator<=>(const Point&) const = default;\n};\n\nint main() {\n    Point p1{1, 2}, p2{2, 3};\n    if (p1 < p2) {\n        std::cout << "p1 is less than p2\\n";  \/\/ Output\n    }\n}<\/pre><\/div>\n\n\n\n
6. Calendar and Time Zone Library<\/h4>\n\n\n\n
This library provides comprehensive support for handling dates, times, and time zones.<\/p>\n\n\n\n
#include <chrono>\n#include <iostream>\n\nint main() {\n    using namespace std::chrono;\n    auto now = system_clock::now();\n    auto today = floor<days>(now);\n    std::cout << "Today is: " << today.time_since_epoch().count() << " days since epoch\\n";\n}<\/pre><\/div>\n\n\n\n
C++20 significantly enriches the language, making it more modern and powerful for a wide range of programming tasks. These features together improve the robustness, readability, and maintainability of C++ code.<\/p>\n\n\n\n
C++23<\/h4>\n\n\n\n
C++23 introduces several powerful features that enhance the language’s capabilities, safety, and ease of use. Here\u2019s a detailed look at some of the most significant additions:<\/p>\n\n\n\n
1. std::expected<\/h4>\n\n\n\n
std::expected<\/code> is a new utility for error handling, similar to std::optional<\/code> but with built-in error state management.<\/p>\n\n\n\n
Example<\/strong>:<\/p>\n\n\n\n
#include <iostream>\n#include <expected>\n\nstd::expected<int, std::string> divide(int a, int b) {\n    if (b == 0) {\n        return std::unexpected("Division by zero!");\n    }\n    return a \/ b;\n}\n\nint main() {\n    auto result = divide(10, 0);\n    if (!result) {\n        std::cout << "Error: " << result.error() << '\\n';\n    } else {\n        std::cout << "Result: " << *result << '\\n';\n    }\n}<\/pre><\/div>\n\n\n\n
2.std::mdspan<\/h4>\n\n\n\n
std::mdspan<\/code> is a multi-dimensional array view, providing a way to describe the shape and layout of data in memory.<\/p>\n\n\n\n
Example<\/strong>:<\/p>\n\n\n\n
#include <iostream>\n#include <mdspan>\n\nint main() {\n    int data[6] = {1, 2, 3, 4, 5, 6};\n    std::mdspan<int, std::extents<2, 3>> mdspan(data);\n    for (int i = 0; i < 2; ++i) {\n        for (int j = 0; j < 3; ++j) {\n            std::cout << mdspan(i, j) << ' ';\n        }\n        std::cout << '\\n';\n    }\n}<\/pre><\/div>\n\n\n\n
3. Reflection (Experimental)<\/h4>\n\n\n\n
C++23 introduces experimental reflection capabilities, allowing compile-time introspection of types and their properties.<\/p>\n\n\n\n
Example<\/strong>:<\/p>\n\n\n\n
#include <iostream>\n#include <experimental\/reflect>\n\nstruct MyStruct {\n    int a;\n    double b;\n    void foo() {}\n};\n\nint main() {\n    auto type = reflexpr(MyStruct);\n    for (auto member : type.get_data_members()) {\n        std::cout << "Member name: " << member.get_name() << '\\n';\n    }\n}<\/pre><\/div>\n\n\n\n
4.if consteval<\/h4>\n\n\n\n
The if consteval<\/code> statement allows code to check if it is being evaluated at compile-time.<\/p>\n\n\n\n
Example<\/strong>:<\/p>\n\n\n\n
#include <iostream>\n\nconstexpr int factorial(int n) {\n    if consteval {\n        if (n < 0) throw "Negative input!";\n    }\n    return n <= 1 ? 1 : n * factorial(n - 1);\n}\n\nint main() {\n    std::cout << factorial(5) << '\\n'; \/\/ OK\n    \/\/ std::cout << factorial(-1) << '\\n'; \/\/ Compile-time error\n}<\/pre><\/div>\n\n\n\n
5.[[assume]] Attribute<\/h4>\n\n\n\n
The [[assume]]<\/code> attribute allows developers to provide assumptions to the optimizer, improving performance by informing the compiler about invariants.<\/p>\n\n\n\n
Example<\/strong>:<\/p>\n\n\n\n
#include <iostream>\n\nint main() {\n    int x = 5;\n    [[assume(x > 0)]];\n    std::cout << "x is positive.\\n";\n}<\/pre><\/div>\n\n\n\n
<\/p>\n\n\n\n
These features have significantly enhanced C++\u2019s expressiveness, safety, and performance, keeping it a robust choice for modern software development. But how many of them have you already used?<\/p>\n","protected":false},"excerpt":{"rendered":"
Modern C++ has seen a series of significant updates starting from C++11, each bringing new features and enhancements that aim to make the language more efficient, readable, and maintainable. Here’s a brief overview of the major features introduced in each version since C++11, along with a comment on their usage: C++11 C++11 marked a significant … Continue reading “C++26 is coming, but what are the major features that have been added to C++ since C++11?”<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[654,632,642,656,475,658,71,657,655,627,628,629,630,631,626,508,47,634,504,18,641,643,649,502,637,653,648,488,30,215,494,489,633,503,652,639,226,506,646,650,640,651,644,635,645,647,505,509,636,638,492],"class_list":["post-1809","post","type-post","status-publish","format-standard","hentry","category-uncategorized","tag-assume-attribute","tag-auto-type-deduction","tag-binary-literals","tag-c-enhancements","tag-c-evolution","tag-c-improvements","tag-c-programming","tag-c-standard","tag-c-updates","tag-c11-features","tag-c14-features","tag-c17-features","tag-c20-features","tag-c23-features","tag-c26","tag-calendar-library","tag-concepts","tag-constexpr","tag-coroutines","tag-cppdepend","tag-deprecated-attribute","tag-digit-separators","tag-filesystem-library","tag-fold-expressions","tag-generic-lambdas","tag-if-consteval","tag-if-constexpr","tag-lambda-expressions","tag-modern-c","tag-modules","tag-move-semantics","tag-nullptr","tag-range-based-for-loops","tag-ranges","tag-reflection-in-c","tag-return-type-deduction","tag-smart-pointers","tag-spaceship-operator","tag-stdany","tag-stdexpected","tag-stdmake_unique","tag-stdmdspan","tag-stdoptional","tag-stdthread","tag-stdvariant","tag-structured-bindings","tag-three-way-comparison","tag-time-zone-library","tag-uniform-initialization","tag-variable-templates","tag-variadic-templates"],"_links":{"self":[{"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/posts\/1809","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/comments?post=1809"}],"version-history":[{"count":7,"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/posts\/1809\/revisions"}],"predecessor-version":[{"id":1819,"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/posts\/1809\/revisions\/1819"}],"wp:attachment":[{"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/media?parent=1809"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/categories?post=1809"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/cppdepend.com\/blog\/wp-json\/wp\/v2\/tags?post=1809"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}