Quelle est la différence en pratique entre en ligne et #define?

Comme le dit le titre; quelle est la différence dans la pratique, entre le mot-clé inline et le #define directive de préprocesseur?

double possible de les fonctions Inline vs macros du Préprocesseur

OriginalL'auteur eliego | 2010-08-24

  1. 39

    #define est un outil du préprocesseur et a macro-sémantique. Considérez ceci, si max(a,b) est une macro définie comme

    #define max(a,b) ((a)>(b)?(a):(b)):

    Ex 1:

    val = max(100, GetBloodSample(BS_LDL)) serait déversement supplémentaire de sang d'innocents, parce que la fonction sera effectivement appelée deux fois. Cela peut signifier la différence de performances significative pour des applications réelles.

    Ex 2:

    val = max(3, schroedingerCat.GetNumPaws())
    Cela démontre une sérieuse différence dans la logique du programme, parce que cela peut inattendue de retourner un nombre qui est inférieur à 3 - quelque chose que l'utilisateur ne s'attendrait pas.

    Ex 3:

    val = max(x, y++) peut incrémenter y plus d'une fois.

    Avec les fonctions inline, aucun de ces va arriver.

    La raison principale est que la macro concept des objectifs de transparence, de mise en œuvre (texte de code à remplacer) et dans la ligne des cibles langue appropriée des concepts, faire de la sémantique d'invocation plus transparente pour l'utilisateur.

    +1 Pour l'effusion de sang exemple
    Vous devriez changer de shroedingerCat.GetNumPaws() à une fonction C, pas du C++.
    Eh bien, la question est à propos de C; il est bien plus commun pour le C++ des fonctions de membre du retour des choses différentes de temps en temps, parce que, naturellement, ils s'appuient sur l'état de leur objet.
    Thx pour la grande réponse avec beaucoup d'exemples =)
    Je ne vois pas de différence entre Ex1 et Ex2, vous êtes à l'appel de max sur deux valeurs différentes.

    OriginalL'auteur Pavel Radzivilovsky

  2. 2

    Fonctions (inline ou pas) et les macros de répondre à différentes fins. Leur différence ne devrait pas être considéré comme idéologique, comme certains semblent le prendre, et ce qui est encore plus important, ils peuvent travailler bien ensemble.

    Les Macros sont des textes de remplacement est effectué au moment de la compilation, et ils peuvent faire des choses comme

    #define P99_ISSIGNED(T) ((T)-1 < (T)0)

    qui vous donne un moment de la compilation de l'expression de l'existence ou non d'un type intégral est signé ou non. Qui est, ils sont idéalement utilisés lorsque le type d'une expression n'est pas connue (la définition) et que vous voulez faire quelque chose à ce sujet. D'autre part, le piège avec les macros, c'est que leurs arguments peut être évalué à plusieurs reprises, ce qui est mauvais à cause des effets secondaires.

    Fonctions (inline) sur l'autre sont typées, ce qui les rend plus strict ou, formulé de manière négative, moins souple. Considérons les fonctions

    inline uintmax_t absU(uintmax_t a) { return a; }
inline uintmax_t absS(uintmax_t a) {
   return (-a < a) ? -a : a;
}

    La première met en œuvre le trivial abs fonction pour un unsigned type intégral. La seconde met en œuvre, pour un type signé. (oui, il faut un unsigned comme argument, c'est pour la fin.)

    Nous pouvons les utiliser avec n'importe quel type intégral. Mais, le type de retour sera toujours de la plus grande largeur et il y a une certaine difficulté sur le fait de savoir comment choisir entre les deux.

    Maintenant avec la macro suivante

    #define ABS(T, A) ((T)(P99_ISSIGNED(T) ? absS : absU)(A))

    nous avons mis en place un

    • famille de fonctions
    • qui fonctionne pour tout type intégral
    • qui évalue son argument qu'une seule fois
    • pour qui toute récente et décent
      le compilateur va créer un code optimal

    (Bon, j'avoue que de le faire avec abs est un peu artificiel, mais j'espère que vous obtenez l'image.)

    OriginalL'auteur Jens Gustedt

  3. 1

    Macros (créé avec #define) sont toujours remplacés comme l'écrit, et peut avoir double-problèmes liés à l'évaluation.

    inline d'autre part, est purement consultatif - le compilateur est libre de l'ignorer. En vertu de la norme C99, un inline fonction peut également avoir une liaison externe, la création d'une définition de fonction qui peuvent être liées.

    OriginalL'auteur caf

  4. 1

    Bien, un multi-ligne #define est plus difficile d'écrire et d'éditer qu'une fonction inline. Vous pouvez définir une fonction inline comme une fonction normale, et peut définir des variables sans problèmes. Imaginez que vous voulez l'appeler d'un code-block plusieurs fois dans une autre fonction, et que le bloc de code a besoin de ses propres variables: il est plus facile à faire avec les fonctions inline (oui, vous pouvez le faire avec #définit et do { ... } while (0); mais c'est quelque chose que vous avez à penser).

    Aussi, avec l'option de débogage, vous pouvez normalement obtenir un "simulé" pile-cadre pour les fonctions inline et qui pourraient en faire un débogage plus facile parfois (du moins c'est ce que vous obtenez lorsque vous compilez/lien avec gcc est -g et de débogage à l'aide de GDB, IIRC). Vous pouvez placer des points d'arrêt à l'intérieur de votre inline avais fonction.

    En outre, le résultat devrait être à peu près identique, autant que je sache.

    OriginalL'auteur DarkDust

  5. 0

    La différence est décrite en détail ici :
    http://www.geekinterview.com/question_details/23831
    cheers

    OriginalL'auteur tarrasch

  6. 0

    Fonction-comme les macros vous donner absolument zéro vérifications à l'endroit où elles sont définies. Lorsque vous vis avec une macro, ça marchera très bien dans un endroit et être cassé quelque part d'autre, et vous ne savez pas pourquoi jusqu'à ce que vous avez perdu plusieurs heures de travail/temps de sommeil. Fonction-comme les macros ne fonctionnent pas sur des données, ils fonctionnent dans le code source. Parfois, c'est bon, par exemple lorsque vous voulez réutilisables instructions de débogage qui utilisent FICHIER et LIGNE objets internes, mais la plupart du temps, il peut être fait tout aussi bien avec une fonction inline, ce qui est vérifié pour la syntaxe au point de définition, tout comme toute autre fonction.

    OriginalL'auteur Chris