C++17

Permite la definición de variables en archivos de cabecera. El compilador elige donde se instancia la variable.

El especificador inline puede ser aplicado tanto a funciones como variables. Una variable declarada inline tiene la misma semántica que una función declarada inline: puede ser definida, de forma idéntica, en múltiples unidades de traducción (esto es, un archivo .c/.cpp una vez que todos los archivos de cabecera han sido incluidos), y ha de ser definida en cada una de esas unidades de traducción donde va a ser usada.

El comportamiento del programa es como si hubiese exactamente una variable.

En C++14, aunque había soporte para usar variables estáticas en plantillas de clase, no había modo conveniente de hacerlo. Por tanto, uno debía recurrir a trucos como  este:

template< class Dummy > 
struct Kath_ 
{
 static std::string const hi; 
};

template< class Dummy > 
std::string const Kath_<Dummy>::hi = "Zzzzz..."; 
using Kath = Kath_<void>; //Permite escribir `Kath::hi`.

Y desde C++17, podemos hacer en un archivo de encabezado:

struct Kath 
{ 
static std::string const hi; 
}; 

inline std::string const Kath::hi = "Zzzzz..."; //Más simple

Para la inicialización de copia de lista, la deducción auto deducirá un std::initializer_list (si los tipos de entradas en la lista de inicialización arriostrada son todos idénticos) o de lo contrario estará mal constituida.

Para la inicialización de listas directa:

• Para una lista de inicialización arriostrada con un solo elemento, la deducción automática deducirá a partir de esa entrada.

• Para una lista de inicialización arriostrada con más de un elemento, la deducción automática se constituirá de forma errónea.

Las reglas para los for basados en rango no serán afectadas por los cambios propuestos aquí, ya que las reglas para la inicialización de copia de lista no se han modificado.

Enlaza los nombres especificados a subobjetos o elementos del inicializador.

Como una referencia, un enlace estructurado es un alias a un objeto existente. Sin embargo, y al contrario que en una referencia, el tipo del enlace estructurado no tiene que ser un tipo referencia.

La declaración de un enlace estructurado introduce todos los identificadores en la lista de identificadores como nombres del scope circundante y los enlaza a subobjetos o elementos del objeto denotado por expresión. Los enlaces de este tipo son llamados enlaces estructurados. Lo que permite expresiones como:

const auto [it, inserted] = map.insert( {"foo", bar} );
//Crea las variables it e inserted con el tipo deducido del par que map::insert retorna.

auto [a, b] = getTwoReturnValues();

Invoca cualquier llamable (puntero de función, función, puntero miembro) con una única sintaxis. Viene del concepto del estándar INVOKE.

Como ejemplo, considera el deref_fn wrapper, que debería aceptar cualquier objeto llamable f y retornar un functor que invoca al llamable proveído y desreferencia el resultado.

Usando C++14, podría implementarse así:

template<typename F, std::enable_if_t<!std::is_member_pointer<std::decay_t<F>>{}, int> = 0>
auto deref_fn(F&& f) 
{ 
return [f](auto&&... args) { return *f(std::forward<decltype(args)>(args)...); };
} 

template<typename F, std::enable_if_t<std::is_member_pointer<std::decay_t<F>>{}, int> = 0>
auto deref_fn(F&& f)
{ 
return [mf = std::mem_fn(f)](auto&&... args) { return *mf(std::forward<decltype(args)>(args)...); };
}

La función invoke propuesta permite una implementación más simple, que no depende del uso de la sobrecarga de función SFINAE:

template<typename F>
auto deref_fn(F&& f) 
{ 
return [f](auto&&... args) { return *std::invoke(f, std::forward<decltype(args)>(args)...); };
}

El actual sistema basado en rango para bucles es demasiado restrictivo. El iterador end nunca es incrementado, decrementado o desreferenciado. El requerimiento de que sea un iterador no tiene sentido por tanto.

Hoy en día, los algoritmos STL requieren que el begin y end de un rango tengan el mismo tipo. Es algo sensato teniendo en cuenta que los algoritmos toman el begin y el end de un rango como parámetros separados. En la ausencia de comprobación, permitir que sus tipos difieran hace bastante fácil el pasar iteradores que no se correspondan entre ellos. Esto no ocurre con el sistema basado en rango para bucles, puesto que se hace cargo de los rangos de forma completa.

Perder los requerimientos de tipo basados en rango para bucles proporciona a los usuarios de Ranges TS la mejor experiencia posible. Si los usuarios crean rangos con Ranges TS que no son usables con los rangos basados en bucle por defectos, se sentirían frustrados, y no tendrá mucha utilidad. Con toda probabilidad, una solución basada en macro como BOOST_FOREACH será inventada para llenar el hueco.

Por tanto, es un apoyo a centinelas, o iteradores end que no son del mismo tipo que el begin iterator, que ayuda con los bucles terminados en null y parecidos.

Si necesitas una función suma, que admita un número ilimitado de parámetros, en C++17 se puede hacer de una forma muy simple:

template <typename... Args>
auto sum(Args&&... args) {
   return (args + ... + 0);
}

Permite declarar varios namespaces en una sola  sentencia:

//En C++14
namespace A{
    namespace B {
        bool check();
    }
}

//En C++17 
namespace A::B {
    bool check();
}

Se añade a la librería estándar este namespace con el tipo path y métodos para iterar y operar con directorios:

#include <filesystem>
#include <iostream>
namespace fs = std::filesystem;
 
void main(){
  fs::path dir = "/";
  dir /= "sandbox";
  fs::path p = dir / "foobar.txt";
  std::cout << p.filename() << "\n";
  fs::copy(dir, "/copy", fs::copy_options::recursive);
}

Inicializadores en las sentencias if y switch, ahora permiten evaluar condiciones en inicializadores que no son convertibles a booleanos.

//Antes
auto p = map.try_emplace(key, value);   
if (!p.second) {     
    //ERROR
} else {     
    //OK
}

//Ahora
if (auto p = map.try_emplace(key, value); !p.second) {
    //ERROR
} else {
    //OK
}

Un objeto de la clase any almacena una instancia de cualquier tipo que satisface los requisitos del constructor o que está vacío,. El objeto almacenado es conocido como objeto contenido. Dos estados son equivalentes si ambos están vacíos o si los objetos contenidos son iguales. Las implementaciones de esta clase deben evitar el uso de memoria reservada dinámicamente para el objeto contenido.

std::any v = ...;
if (v.has_value()) {
   // se cumple si no es un entero
   int i = any_cast<int>(v);
}

Representa objetos que pueden o no existir. El uso más común para esto es asignarlo a un valor que devuelve una función que puede fallar. El objeto contenido puede ser inicializado después de que el objeto opcional haya sido inicializado, y puede ser destruido antes de que el objeto opcional lo haya sido. El estado de inicialización del objeto contenido está monitorizado por el objeto opcional.

std::optional opt = f();
std::cout << opt.value_or(0) << std::endl;

La plantilla de clase std::variant representa un tipo de unión segura. Una instancia de  std::variant en cualquier tiempo dado sostiene un valor de los tipos alternativos o, en caso de error, ningún valor. A la variante no se le permite asignar memoria dinámicamente.

std::variant<int, double, std::vector> numero; // numero puede ser un int, un double o un std::vector

Permite usar los switches en cascada sin que el compilador emita warning.

switch (device.status())
{
case sleep:
   device.wake();
   [[fallthrough]];
case ready:
   device.run();
   break;
case bad:
   handle_error();
   break;
}