Suport technique et veille technologique

LinuxFr.org : les journaux  -  Une 20-aine de lignes de code pour le defer de Go en C++

 -  Février 2022 - 

Bonjour Nal,

Si tu es comme moi, tu détestes Go malgré quelques fonctionnalités géniales et un écosystème vaste et grandissant, qui en font un choix à considérer malgré tes préférences personnelles.

Si tu es comme moi, tu préfères certainement le C++ surtout depuis le C++11. Tu fais d'ailleurs surement du C++20 histoire d'être moderne.

Parmi les fonctionnalités de Go que tu apprécies, il y a le mot clé defer :

func example() error {
  rsrc1, err := CreateResource()
  if err != nil {
    return err
  }
  defer rsrc1.Destroy()

  rsrc2, err := CreateResource()
  if err != nil {
    return err
  }
  defer rsrc2.Destroy()

  DoSomething(rsrc1, rsrc2)

  return nil
}

TL;DR : Il permet d'exécuter du code lorsque l'on quitte cette dernière.

Je veux la même chose en C++. Et en vrai, cela se fait assez simplement. On va juste profiter du concept de destructeur :

#include 
#include 
#include 

class defer_frame {
  public:
    using function = std::function<void(void)>;

  private:
    std::vector<function> m_funcs;

  public:
    ~defer_frame() {
      std::for_each(m_funcs.rbegin(), m_funcs.rend(), [](auto &f) {
        f();
      });
    }

    void defer(function fn) {
      m_funcs.push_back(fn);
    }
};

Mais que fait cette classe ? Elle stocke tout simplement un ensemble de fonctions, et lorsque l'instance de la classe est détruite, elle appelle ces fonctions dans l'ordre inverse de leur déclaration.

Quand est-ce qu'est appelé le destructeur d'une classe ? Lorsque l'on quitte la scope actuelle, c'est à dire dans l'un des cas suivants :

• un a atteint la fin du scope avec }
• on quitte la boucle avec break
• on quitte la fonction avec return
• on lève une exception avec throw

Ce qui donne :

void example() {
  defer_frame _;

  auto rsrc1 = create_resource(); // throws on failure
  _.defer([&]() { destroy_resource(rsrc1); });

  auto rsrc2 = create_resource();
  _.defer([&]() { destroy_resource(rsrc2); });

  do_something(rsrc1, rsrc2);
}

La gestion d'erreur est tout de suite un peu plus propre :)

Histoire de taper un peu moins de code, on peut se créer 2 petites macros :

#define new_defer_frame() defer_frame _
#define defer(code_block) _.defer([&]() code_block)

Un petit exemple avec la SDL pour la route :

#include 
#include 

void abort_sdl() {
  throw std::runtime_error(SDL_GetError());
}

void run_sdl_program() {
  new_defer_frame();

  if (SDL_Init(SDL_INIT_EVERYTHING) < 0) {
    abort_sdl();
  }
  defer({ SDL_Quit(); });

  auto win = SDL_CreateWindow(
    "example",
    SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
    800, 600,
    SDL_WINDOW_SHOWN
  );
  if (win == nullptr) {
    abort_sdl();
  }
  defer({ SDL_DestroyWindow(win); });

  auto renderer = SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED);
  if (renderer == nullptr) {
    abort_sdl();
  }
  defer({ SDL_DestroyRenderer(renderer); });

  bool running = true;
  while (running) {
    SDL_Event evt;

    while (SDL_PollEvent(&evt)) {
      switch (evt.type) {
        case:
          running = false;
          break;

        default:
          break;
      }
    }
  }
}

Commentaires : voir le flux Atom ouvrir dans le navigateur

par David Delassus