What are the new features in C++ 17 ?

In C++17, numerous new features and enhancements have been introduced, significantly improving programming convenience and efficiency. Below, I will list some of the key new features and provide simple examples to illustrate their usage.

1. Structured Bindings Structured bindings enable programmers to destructure multiple variables from arrays or tuples simultaneously, simplifying code. For example:

   cpp
   std::pair<int, double> p = {1, 2.3};
   auto [x, y] = p; // x = 1, y = 2.3

2. Inline Variables Inline variables primarily address multiple definition issues when declaring global variables in header files. Using the inline keyword ensures that global variables have a single definition across multiple source files. For example:

   cpp
   inline int globalVal = 10;

3. Filesystem Library C++17 officially introduced the filesystem library, simplifying file and directory operations. For example, checking if a file exists:

   cpp
   #include <filesystem>
   namespace fs = std::filesystem;
   
   int main() {
       fs::path p = "/path/to/some/file.txt";
       if (fs::exists(p)) {
           std::cout << "File exists." << std::endl;
       } else {
           std::cout << "File does not exist." << std::endl;
       }
       return 0;
   }

4. std::optional std::optional provides a safe way to handle cases where a value may or may not be present, avoiding null pointers. For example:

   cpp
   #include <optional>
   
   std::optional<int> GetInt(bool fetch) {
       if (fetch) {
           return 5;
       } else {
           return {}; // Empty std::optional
       }
   }
   
   int main() {
       auto val = GetInt(true);
       if (val.has_value()) {
           std::cout << "Value: " << *val << std::endl;
       }
       return 0;
   }

5. Initialization Statements for if and switch This allows adding an initialization statement before the condition part of if or switch statements, making the code more concise and readable. For example:

   cpp
   std::vector<int> vec = {1, 2, 3, 4};
   if (auto it = std::find(vec.begin(), vec.end(), 3); it != vec.end()) {
       *it = 10; // Modify the found element
   }

6. Parallel Algorithms C++17 added parallel versions of algorithms to the standard library, leveraging modern hardware's multi-core capabilities to accelerate execution. For example, using parallel sorting:

   cpp
   #include <algorithm>
   #include <vector>
   #include <execution>
   
   int main() {
       std::vector<int> v = {9, 1, 10, 2, 45, 3, 90, 4, 9, 5, 7};
       std::sort(std::execution::par, v.begin(), v.end());
       for (int n : v) {
           std::cout << n << ' ';
       }
       std::cout << '\n';
   }

These features not only enhance the language's functionality and expressiveness but also further strengthen the ability to write safe and efficient code.