C peut-il obtenir une fonctionnalité de report de style Go avec une surcharge minimale ?

Implémentation standard du délai/terminateur en C

La fonction de délai en langage Go est un moyen d'exécuter un bloc de code lorsque la fonction se termine Mécanisme qui simplifie le nettoyage des ressources et la gestion des erreurs. Cet article explore la possibilité d'une implémentation différée similaire en C et la faisabilité d'alternatives dans les bibliothèques existantes.

Implémentations existantes

La bibliothèque standard C, Boost et d'autres bibliothèques tierces ne fournissent pas encore d'implémentations paresseuses prêtes à l'emploi. Cependant, l'implémentation personnalisée légère suivante fournit des fonctionnalités similaires au langage Go :

<code class="cpp">struct defer_dummy {};
template <class F> struct deferrer { F f; ~deferrer() { f(); } };
template <class F> deferrer<F> operator*(defer_dummy, F f) { return {f}; }
#define DEFER_(LINE) zz_defer##LINE
#define DEFER(LINE) DEFER_(LINE)
#define defer auto DEFER(__LINE__) = defer_dummy{} *[&]()</code>

Utilisation

Cette implémentation est utilisée de la même manière que le langage Go Delay la syntaxe est similaire :

<code class="cpp">defer {
    // 要在函数退出时执行的代码块
};</code>

Exemple d'utilisation

<code class="cpp">#include <cstdio>
#include <cstdlib>

bool read_entire_file(char *filename, std::uint8_t *&data_out,
                      std::size_t *size_out = nullptr) {
    auto file = std::fopen(filename, "rb");
    if (!file)
        return false;

    defer { std::fclose(file); }; // 自动关闭文件

    // ...其他文件操作代码

    return true;
}

int main(int argc, char **argv) {
    if (argc < 2)
        return -1;

    std::uint8_t *file_data = nullptr;
    std::size_t file_size = 0;

    auto read_success = read_entire_file(argv[1], file_data, &file_size);

    defer { delete[] file_data; }; // 自动释放文件数据

    if (read_success) {
        // ...文件处理代码

        return 0;
    } else {
        return -1;
    }
}</code>

Avantages

• Aucun Overhead : Cette implémentation n’introduit aucune surcharge supplémentaire, contrairement à d’autres implémentations basées sur des objets ou des pointeurs intelligents.
• Syntaxe facile : la syntaxe imite la syntaxe paresseuse du langage Go, rendant le code plus clair et plus facile à lire.
• Zéro dépendance : L'implémentation est complètement autonome et n'augmente pas le temps de compilation.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!