New standard library features in Visual C++ 2017 RC

The new Visual C++ 2017, currently in release candidate phase, provides a series of updates and fixes to both the C++ compiler and the standard library. A comprehensive list of these improvements is available at What’s New for Visual C++ in Visual Studio 2017 RC.

In this article, I want to shortly look at the new standard library features from VC++ 2017.

• std::any (available in header <any>) is a class that represents a type-safe container that can hold the value of any copy-constructible object. To read the value stored in an any variable you need to use the non-member function std::any_cast.
  C++

  std::any value{ 10 }; // int 10 value = 10.0; // double 10.0 value = "10"s; // string "10" if(value.has_value()) { if (value.type() == typeid(std::string)) { std::cout << "value=" << std::any_cast<std::string>(value) << std::endl; } }

  1 2 3 4 5 6 7 8 9 10 11 12 13

  std::any value{ 10 };   // int 10 value = 10.0;           // double 10.0 value = "10"s;          // string "10"   if(value.has_value()) {    if (value.type() == typeid(std::string))    {       std::cout << "value="                 << std::any_cast<std::string>(value)                 << std::endl;    } }

• std::optional (available in header <optional>) is a class template that may or may not contain a value any moment in time. If it contains a value, it is allocated as part of the optional object, and therefore does not incur any memory overhead.
  C++

  auto string_part( std::string const & text, std::optional<int> start, std::optional<int> end) { auto s = start.value_or(0); auto e = end.value_or(text.length()); return text.substr(s, e - s); } auto lprint = [](auto const & value) { if (value.has_value()) std::cout << *value << std::endl; else std::cout << "[no value]" << std::endl; }; std::optional<int> value; lprint(value); value = 10; lprint(value); std::cout << string_part("marius"s, {}, {}) << std::endl; // prints "marius" std::cout << string_part("marius"s, {1}, {4}) << std::endl; // prints "ari"

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

  auto string_part(    std::string const & text,    std::optional<int> start,    std::optional<int> end) {    auto s = start.value_or(0);    auto e = end.value_or(text.length());    return text.substr(s, e - s); }   auto lprint = [](auto const & value) {    if (value.has_value())       std::cout << *value << std::endl;    else       std::cout << "[no value]" << std::endl; };   std::optional<int> value; lprint(value);   value = 10; lprint(value);   std::cout << string_part("marius"s, {}, {}) << std::endl;   // prints "marius" std::cout << string_part("marius"s, {1}, {4}) << std::endl; // prints "ari"

• std::variant (available in header <variant>) is a class template that represents a type-safe union. A variant can hold any number of alternatives, but they cannot be of type reference, array or void. The first alternative must be default constructible, because variants are default constructible and a default-constructed variant object contains a value of its first alternative. If the first alternative is not default-constructible, std::monostate (an empty, default-constructible class) can be used for that purpose. If it contains a value, it is allocated as part of the variant object, and therefore does not incur any memory overhead.
  C++

  std::variant<int, double, std::string> value; value = 10; // int 10 value = 10.0; // double 10.0 value = "10"s; // string "10" std::cout << std::get<std::string>(value) << std::endl; // prints "10" std::cout << std::get<2>(value) << std::endl; // prints "10" std::cout << "index = " << value.index() << std::endl; // prints 2 std::visit([](auto&& arg) {std::cout << arg << std::endl; }, value);

  1 2 3 4 5 6 7 8 9 10

  std::variant<int, double, std::string> value; value = 10;    // int 10 value = 10.0;  // double 10.0 value = "10"s; // string "10"   std::cout << std::get<std::string>(value) << std::endl;  // prints "10" std::cout << std::get<2>(value) << std::endl;            // prints "10"         std::cout << "index = " << value.index() << std::endl;   // prints 2   std::visit([](auto&& arg) {std::cout << arg << std::endl; }, value);

• std::basic_string_view (available in header <string_view>) is a class template that represents a view of a contigous sequence of characters (defined by a pointer to the start of the sequence and a count). Several type aliases are available:
  C++

  using string_view = basic_string_view<char>; using u16string_view = basic_string_view<char16_t>; using u32string_view = basic_string_view<char32_t>; using wstring_view = basic_string_view<wchar_t>;

  1 2 3 4

  using string_view    = basic_string_view<char>; using u16string_view = basic_string_view<char16_t>; using u32string_view = basic_string_view<char32_t>; using wstring_view   = basic_string_view<wchar_t>;

  basic_string_view has an interface almost identical to basic_string so that switching from the later is as simple as possible. A typical useage of this class template is for function parameters as a replacement for constant references to basic_string.

  auto string_part( std::string_view text, std::optional<int> start, std::optional<int> end) { auto s = start.value_or(0); auto e = end.value_or(text.length()); return text.substr(s, e - s); } std::cout << string_part("marius"s, {}, {}) << std::endl; std::cout << string_part("marius"s, { 1 }, { 4 }) << std::endl;

  1 2 3 4 5 6 7 8 9 10 11 12

  auto string_part(    std::string_view text,    std::optional<int> start,    std::optional<int> end) {    auto s = start.value_or(0);    auto e = end.value_or(text.length());    return text.substr(s, e - s); }   std::cout << string_part("marius"s, {}, {}) << std::endl; std::cout << string_part("marius"s, { 1 }, { 4 }) << std::endl;

Additional new supported C++17 standard library features are:

• std::apply is a function template that invokes a specified callable object with a tuple of arguments.
• std::make_from_tuple is a function template that creates an object by invocking its constructor with the members of a specified tuple.

To have all these available the /std::c++latest compiler switch must be used. This can be also set from the project properties, at C/C++ > Language > C++ Language Support.