Xavier Lamorlette

C++ 17

Syntaxe

Variables inline

Comme pour les fonctions, permet de définir une variable dans plusieurs unités de compilation, avec résolution à l'édition de lien.

Namespaces

namespace A::B::C {
}

Structured binding declarations

std::map<int, std::string> a_map;
auto[iter, succeeded] = a_map.insert(value);

Initialisations dans les if et switch

std::map<int, std::string> a_map;
if (auto[iter, succeeded] = a_map.insert(value); succeeded) {
  use_result(iter);
}

Compilation conditionnelle (constexpr if)

template<typename T>
auto Get_value(T t) {
  if (constexpr(std::is_pointer_v<T>)) {
    return * t;
  } else {
    return t;
  }
}

Attribut maybe_unused

voip F([[maybe_unused]] bool a) {
  [[maybe_unused]] bool b = a;
  assert(b);
}

Garantie de l'élision de copie

Le Return Value Optimisation (RVO) est garanti.

STL

À étudier : Standard Library Utilities in C++.

std::any

std::byte

Pour stocker un octet.

std::optional

std::string_view

Référence non propriétaire vers une string.

std::variant

Type somme : type combinant la somme disjointe des valeurs des différentes parties (comme les unions en C).

std::visit est une fonction qui prend en paramètre un visiteur.

Exemple d'utilisation de std::visit avec auto :

using A_or_B = std::variant<A, B>;

std::ostream & operator << (std::ostream & os,
        const A_or_B & a_or_b) {
    std::visit([& os](auto const & element){
        os << element;
    }, a_or_b);
  return os;
}

Exemple d'utilisation de std::visit avec des surcharges :

struct A_or_B_visitor {
    std::ostream & os;

    A_or_B_visitor(std::ostream & os):
        os(os) {
    }

    void operator () (const A & a) {
        os << "A: " << a;
    }
    void operator () (const B & b) {
        os << "B: " << b;
    }
};

std::ostream & operator << (std::ostream & os,
        const A_or_B & a_or_b) {
    std::visit(A_or_B_visitor(os), a_or_b);
    return os;
}

Filesystem

Vient de Boost.

À étudier : C++17 Filesystem.

Choix de la version d'un algorithme de la STL

std::vector<int> v;
std::sort(policy, v.begin(), v.end());

policy:

Templates

Déduction template dans le constructeur

Les types des paramètres d'une classe template peuvent être déduits à partir des arguments de son constructeur.

template<typename T>
class Show_me {
public:
  Show_me(const T & t) {
    std::cout << t << std::endl;
  }
};

Show_me(1);
Show_me(1.);

Fold Expressions

Exemples :

template<typename ... Args>
bool All(Args ... args) {
  return (... && args);
}

std::cout << std::boolalpha << All(true, false) << std::endl;

template<typename T, typename ... Args>
T Sum(const Args & ... args) {
    return (args + ...);
}

Sum(1, 1u, 1.);

La dernière mise à jour de cette page date d'octobre 2019.

Le contenu de ce site est, en tant qu'œuvre originale de l'esprit, protégé par le droit d'auteur.
Pour tout commentaire, vous pouvez m'écrire à xavier.lamorlette@gmail.com.