On ne fait pas de la magie

«Toute technologie suffisamment avancée est indiscernable de la magie.» Arthur C. Clarke

Catégorie : C++

  • Visual Studio intègre C++20

    Visual Studio intègre C++20

    [Mise à jour du 6 juin] La version 19.10 est sortie officiellement. Vous pouvez donc l’utiliser pour vos essais !

    Lors de l’écriture des exemples d’une formation sur une nouvelle version de C++, en l’occurrence C++20, une difficulté est de jongler avec les compilateurs, car ils n’intègrent pas tous en même temps toutes les nouvelles fonctionnalités. Depuis peu, la situation s’est simplifiée, car Visual Studio 2019 version 19.10 est disponible en preview avec a priori toutes les fonctionnalités de C++20.

    (suite…)
  • Exercices pour étudier le C++ moderne

    Exercices pour étudier le C++ moderne

    Si vous apprenez le C++, je vous propose une série d’exercices de type fil rouge pour illustrer les points importants à comprendre.
    En effet, lors de l’apprentissage du C++, faire des exercices est très important, car cela permet de mieux comprendre et mémoriser les nombreux éléments que l’on découvre.
    Ces exercices font partie de ceux que j’utilise lors de formations, aussi bien en présentiel qu’à distance.

     

    Continuer la lecture

  • A quoi sert if constexpr en C++ 17 ?

    A quoi sert if constexpr en C++ 17 ?

    C++ 17 a fourni un lot de nouveautés, dont une très utile lors de la compilation, if constexpr, pour faciliter la vie des développeurs. Elle offre plus de possibilités que l’utilisation des #if et autres #ifdef.

    (suite…)
  • Surcharger l’opérateur new pour empêcher l’allocation dynamique d’un objet en C++

    Parfois, il est nécessaire de restreindre des objets pour qu’ils ne puissent être utilisés qu’au travers de variables locales. Un cas typique est une classe qui utilise des ressources, allouées logiquement dans son constructeur, et libérées dans son destructeur.

    Voici un exemple que j’utilise parfois dans les formations au C++.

    Tout va bien si le programme détruit les objets lorsqu’ils n’en a plus besoin.
    C’est le cas si on emploie ces objets à l’aide de variables locales : lorsque le programme quitte la portée dans laquelle la variable existe (nous présumons bien sûr que la variable n’est pas statique), l’objet est détruit, et le passage dans le destructeur libère les ressources allouées dans le constructeur.

    Le risque est qu’un développeur crée un objet en utilisant une allocation dynamique, car il pourrait ensuite oublier de détruire cet objet, bloquant ainsi les ressources.

    Une solution pour supprimer ce risque consiste tout simplement à surcharger l’opérateur new de notre classe, de façon à empêcher l’allocation dynamique d’objets de cette classe. Voici un petit exemple qui montre le principe :

    class maClasse {
    public:
          string chaine;
          maClasse() {
    // allocation des ressources
         chaine = "Les ressources sont allouees";
    };
    ~maClasse() {
    // libération des ressources
          cout << "Les ressources sont liberees" << endl;
    }
    void *operator new (size_t taille) {
    throw 0;
    return new int; // peut renvoyer n'importe quoi : on ne passera jamais ici
    }
    };
    int main(int argc, char* argv[]) {
    { 
    // bloc pour montrer la réservation et la libération des ressources
           maClasse C1;
          cout << C1.chaine << endl;
    }
    try {
          maClasse * pC = new maClasse;
          cout << pC->chaine << endl;
    }
    catch (int e) {
          cout << "Exception : " << e << endl;
    }
    int attente;
    cin >> attente;
    return 0;
    }

    La sortie nous montre que nous avons bien utilisé la variable locale, en allouant, puis en libérant les ressources, mais que l’utilisation d’une allocation dynamique échoue :

    $ ./essai
    Les ressources sont allouees
    Les ressources sont liberees
    Exception : 0