C++17 What is it? Isn't it C++?

C++17 is C++!

It is the sixth revision of the C++ Programming Language, it is not called C++6 because the revisions are not numbered by the revision order but by the year in which the International Organization for Standardization (ISO) approves the revision. language revision (also known as Programming Language Dialect ).

What came before C++17?

This is a brief summary of the history of the C++ language:

• 1985 : First commercial implementation of C++.
• 1989 : Second version of C++.
• 1998 : First ISO ratification of the language. First official dialect of C++ known as C++98 .
• 2003 : Second revision of the language, known as C++03 .
• 2005 : First collection of technical documents (Technical Report) known as TR1.
• 2007 : It is decided to add the TR1 proposals to the standard, this third revision of the language is known as C++TR1 .
• 2011 : Fourth revision of the language, known as C++11 .
• 2014 : Fifth revision of the language, known as C++14 .
• 2017 : Sixth revision of the language, known as C++17 .

What does C++17 add?

Thus, C++17 is nothing more than a revision of the C++ language. What does this revision add compared to previous versions?

Template objects can infer template parameters in a similar way to how they are inferred in template functions:

template <typename T>
void funcion(T t) { /* ... */ }

template <typename T>
struct objeto
{
    objeto(T t) : valor{t} {}
    T valor;
};

int main()
{
    funcion(0);   // Correcto, deduce int t
    funcion('Z'); // Correcto, deduce char t

    objeto o1(0);   // Correcto, deduce int valor. Antes de C++17 es error.
    objeto o2('Z'); // Correcto, deduce char valor. Antes de C++17 es error.

    return 0;
}

However, this deduction does not work exactly the same as the template deduction function, as it does not support partial deduction .

It can be used autoas a template parameter so that the template infers the underlying type of the supplied non-type parameter:

//        vvvv <-- Antes de C++17 no se permite usar auto aqui.
template <auto T>
void funcion() { /* ... */ }

static int i = 0;

int main()
{
    funcion<0>();    // Correcto, T sera de tipo int con valor 0
    funcion<'Z'>();  // Correcto, T sera de tipo char con valor 'Z'
    funcion<&i>();   // Correcto, T sera de tipo int * con valor 0x????????

    funcion<3.14>(); /* Error, T deberia ser de tipo double,
    pero double y float no se permiten como parametro no-tipo */
    funcion<int>();  // Error, se esperaba un valor no un tipo.

    return 0;
}

When declaring a template-template can now be used interchangeably typenameor class( previously it couldn't ):

//      Correcto en C++17 y anterior --> vvvvv
template <typename T, template<typename> class P>
void funcion1(P<T>) { /* ... */ }
//   Correcto solo a partir de C++17 --> vvvvvvvv
template <typename T, template<typename> typename P>
void funcion2(P<T>) { /* ... */ }

It is possible to apply certain operators on parameter packs in variadic templates:

template <typename ... args>
auto funcion(args ... a) { return (a + ...); }
//          Expresion plegada --> ^^^^^^^^^
int main()
{
    // Devuelve 21
    std::cout << funcion(1, 2, 3, 4, 5, 6); // Se despliega en return 1 + 2 + 4 + 4 + 5 + 6;
    // Devuelve hola mundo
    std::cout << funcion("hola"s, ' ', "mundo"s); // Se despliega en return "hola"s + ' ' + "mundo"s;

    return 0;
}

The folding operators are : +,,,,,,,,,,,,,,,,,,,,,,,,,, y and can be deployed like this : _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _-*/%^&|~=<><<>>+=-=*=/=%=^=&=|=<<=>>===!=<=>=&&||,.*->*

  ( expresion operador ... )
  ( ... operador expresion )
  ( expresion operador ... operador expresion )

When there is only one value between braces, it will be deduced as a value, not as a list:

auto a{'a'}; // a es de tipo char, antes deducia std::initializer_list<char> de un elemento.
auto b{0xb}; // b es de tipo int, antes deducia std::initializer_list<int> de un elemento.
auto c{1.f}; // c es de tipo float, antes deducia std::initializer_list<float> de un elemento.

Having a base object like the following:

template <typename T>
struct base
{
    void f(T) { std::cout << __PRETTY_FUNCTION__ << '\n'; }
};

And an object that derives from several base:

template <typename ... T>
struct derivado : base<T> ...
{
};

We can bring into scope derivadoall versions of base<T>::f(T)with a using clause:

template <typename ... T>
struct derivado : base<T> ...
{
    using base<T>::f ...;
};

derivado<int, double, char> d;
/* Equivale a:
using base<int>::f;
using base<double>::f;
using base<char>::f; */

If the lambda meets the requirements to be a constant expression, it can be used as such:

// vvvvvvvvv <-- No se puede usar constexpr aqui antes de C++17
   constexpr auto cinco = [](){ return 5; };

int main(int argc, char **)
{
    switch (argc)
    {
//           vvvvvvv <-- Valido de C++17 en adelante
        case cinco(): /* ... */ break;
        default: std::cout << /* ... */ break;
    }

    return 0;
}

It could be omitted constexprfrom the lambda declaration as they will be constant expressions by default if they meet the requirements to be so.

In a lambda declared inside an object's method, generic catches catch thisas a pointer:

struct objeto
{
    void f()
    {
//                v <-- Captura this por referencia
        auto a = [&]() { valor = 100 ; }; // Equivale a this->valor = 100;
//                v <-- Captura this por copia
        auto b = [=]() { valor = 200 ; }; // Equivale a this->valor = 200;
//                vvvvv <-- Copia el objeto
        auto c = [*this]() mutable { valor = 300 ; } // Equivale a this->valor = 300;

        a(); // this->valor contiene 100
        b(); // this->valor contiene 200
        c(); /* this->valor no se modifica, contiene 200.
                Se modifica el this->valor de una copia */
    }
    int valor;
};

It tells the compiler that the absence of a statement breakat the end of casea switchis intentional:

switch (variable)
{
    case 0:
        // Hacer cosas...
    case 1: // <-- ALarma! falta break!
        // Hacer cosas...
        [[fallthrough]];
    case 2: // <-- Ok, la falta de break es intencionada.
        // Hacer cosas...
        break;
}

Indicates to the compiler that a data type or the return of a function should not be discarded.

//     vvvvvvvvvvvvv <-- Se aconseja no descartar este dato
struct [[nodiscard]] informacion { /* ... */ };
struct datos { /* ... */ };

informacion obtener_informacion() { /* ... */ }
   [[nodiscard]] datos obtener_datos() { /* ... */ }
// ^^^^^^^^^^^^^ <-- Se aconseja no descartar este retorno
int main()
{
    obtener_informacion(); // Alarma! Se esta descartando un objeto de tipo informacion!
    obtener_datos(); // Alarma! Se esta descartando el retorno de obtener_datos!
    return 0;
}

Indicates to the compiler that an entity might not be used intentionally.

[[maybe_unused]] void debug() { std::cout << "Debug\n"; }

void f([[maybe_unused]] int valor)
{
    std::cout << "F!\n";
}

The code above will not display alarms for not using the function debugor not using the value valor.

It is possible to apply attributes on namespaces and enumerated values:

namespace [[deprecated]] utiles
{
void f() { /* ... */ }
}

enum puerto
{
    defecto = 8080,
    entrada = 8016,
    [[deprecated]] salida = 8015
};

void datos(puerto p) { /* ... */ }

int main()
{
    utiles::f(); // Alarma! el espacio de nombres f esta deprecado
    datos(defecto);
    datos(salida); // Alarma! puerto::salida esta deprecado
    return 0;
}

It is possible to make variables behave like functions inline, that is, to treat multiple identical definitions of the variable as the same definition.

The namespace:

namespace Primero
{
namespace Segundo
{
namespace Tercero
{
// Cosas...
}
}
}

can be declared as

namespace Primero::Segundo::Tercero
{
// Cosas...
}

It is no longer mandatory to add a text to static_assert.

As of C++17, if a function does not have a clause throwin its signature, it is considered that it does not throw exceptions.

For functions with multiple return values ​​(returning std::pair, std::tuple, std::arrayand aggregates) it is possible to get each return value separately:

std::map<int, int> mii;
// i y b declarados por separado:
std::map<int, int>::iterator i;
bool b;
//       +---- Asigna el retorno->first a i y el retorno->second a b
//       |     Valido en C++17 y anterior.
//   vvvvvvvvv
std::tie(i, b) = mii.insert({1, 2});

/* iterador e insertado declarados en la misma línea, su tipo se deduce
de retorno->first y retorno->second respectivamente. Asigna el
retorno->first iterador y el retorno->second a insertado.
valido solo a partir de C++17 */
auto [iterador, insertado] = mii.insert({3, 4});
//   ^^^^^^^^^^^^^^^^^^^^^ <--- Emparejamiento estructurado

struct abc { int a, b, c; };
abc f1() { return {2, 3, 5}; }
std::tuple<std::string, float, abc, int> f2() { return {"Hola mundo", 3.14f, {1, 2, 3}, 4}; }
std::array<int, 5> f3() { return {0, 1, 2, 3, 4}; }

// Asigna retorno.a a x, retorno.b a y, retorno.c a z
auto [x, y, z] = f1();
//   ^^^^^^^^^ <--- Emparejamiento estructurado

// Asigna 1r elemento de la tupla a str, segundo a pi, tercero a xyz y cuarto a v
auto [str, pi, xyz, v] = f2();
//   ^^^^^^^^^^^^^^^^^ <--- Emparejamiento estructurado

// Asigna retorno[0] a p0, retorno[1] a p1...
auto [p0, p1, p2, p3, p4] = f3();
//   ^^^^^^^^^^^^^^^^^^^^ <--- Emparejamiento estructurado

It is possible to declare and initialize variables in ifand switch:

if (auto [iterador, insertado] = mii.insert({3, 4}); !insertado)
    std::cout << "Elemento " << iterador->first << " repetido!\n";
else
    std::cout << "Elemento " << iterador->first << "anyadido con valor " << iterador->second << '\n';

switch (int i = f1() + f2(); i)
{
    /* ... */
}

beginAnd in the range for are now allowed to endbe of different types.

It can be added constexprto the clause if. If the condition of the constant condition is not met, the code inside that condition will not compile.

#define DEBUG false

if constexpr (DEBUG)
{
    // Codigo que debe ser compilado solo en modo DEBUG
}

Adding more stuff.