Fonction macro de l'apprentissage du langage C

Fonction macro : 

 #define 宏名(a,b,c,...) a+b*c

    Une fonction macro n'est pas une fonction réelle, mais une macro avec des paramètres, juste utilisée comme une fonction.

    Lors de l'utilisation d'une fonction macro dans le code, il y aura deux substitutions lors du prétraitement. La première fois que la fonction macro est remplacée par une chaîne de codes et d'expressions derrière elle, et la deuxième fois que les paramètres de la fonction macro sont remplacés dans l'expression .

    Si le code derrière la fonction macro comporte plusieurs lignes, vous pouvez utiliser des accolades pour le protéger.

    #définir le nom de la macro(a,b,c,...) {code 1; code 2; ...}

    Le code derrière la fonction macro ne peut pas être encapsulé directement. Si le code est trop long, vous pouvez utiliser le caractère de continuation pour couper la ligne.

    #définir le nom de la macro(a,b,c,...) { \

        code 1;\

        code 2;\

        ... \

}

Avantages et inconvénients des fonctions ordinaires et des fonctions macro :

Avantages des fonctions macro :

            1. La vitesse d'exécution est rapide, ce n'est pas un véritable appel de fonction, mais un remplacement de code, et cela ne passera pas par le passage de paramètres, le saut,

            valeur de retour.

            2. Le type de paramètres ne sera pas vérifié, il est donc très polyvalent.

        Inconvénients des fonctions macro :

            1. Parce qu'il ne s'agit pas d'un véritable appel de fonction, mais d'un remplacement de code, chaque fois qu'il est utilisé, une copie du code sera remplacée, ce qui entraînera une redondance du code, une vitesse de compilation lente et des fichiers exécutables plus volumineux.

            2. Il n'y a pas de valeur de retour et il peut y avoir au plus un résultat d'exécution.

            3. La vérification de type n'est pas stricte et la sécurité est faible.

            4. Les appels récursifs ne peuvent pas être passés.

        Avantages des fonctions :

            1. Il n'y a pas de redondance de code. Le code de la fonction ne sera stocké que dans le segment de code. Lorsqu'il est utilisé, il sautera au passé pour l'exécution et reviendra une fois l'exécution terminée, et la valeur de retour peut également être ajoutée .

            2. Haute sécurité, une vérification de type sera effectuée sur les paramètres.

            3. Des appels récursifs peuvent être effectués pour implémenter l'algorithme diviser pour mieux régner.

        Inconvénients des fonctions :

            1. Par rapport à la fonction macro, sa vitesse d'exécution est plus lente. Lors de l'appel, il passera par le processus de passage des paramètres, de saut, de retour, etc. Ce processus prend beaucoup de temps.

            2. Spécifique au type, quel type de paramètre formel et quel type de paramètre réel doit être, qui ne peut pas être utilisé universellement.

Comment utiliser la fonction macro :

Quel type de code convient à l'encapsulation dans une fonction macro ?

            1. La quantité de code est petite, même si elle est utilisée plusieurs fois, cela ne provoquera pas de redondance excessive dans le segment de code.

            2. Le nombre d'appels est élevé, mais le nombre d'exécutions est élevé.

            3. Il n'y a aucune exigence pour la valeur de retour.

    Éléments à garder à l'esprit lors de la conception de macros :

        1. N'ajoutez pas de point-virgule à la fin.

        2. Ajoutez des parenthèses pour éviter toute ambiguïté.

        3. N'utilisez pas de variables auto-incrémentées et auto-décrémentées pour fournir des paramètres aux fonctions macro.

Encapsuler un malloc, fonction libre

        my_malloc Il doit enregistrer l'emplacement d'appel de my_malloc et l'adresse mémoire demandée

        my_free Il doit enregistrer l'emplacement d'appel de my_free et l'adresse mémoire à libérer

    void* _my_malloc(size_t size,const char* file,const char* func,size_t line)
    {
        void* ptr = malloc(size);
        printf("%s %s %d 申请了%d字节的内存，地址是%p\n",file,func,line,size,ptr);
        return ptr;
    }
    // 由于my_malloc必须有返回值，所以只能使用这种方式中转一下
    #define my_malloc(size) _my_malloc(size,__FILE__,__func__,__LINE__)

    #define my_free(ptr) {\
        free(ptr);\
        printf("%s %s %d 释放了内存 %p\n",__FILE__,__func__,__LINE__,ptr);\
    }