L'aide et retourne le résultat dans C macro

Je suis en train de instrument du code de capture et d'impression des messages d'erreur. Actuellement, je suis en utilisant une macro quelque chose comme ceci:

#define my_function(x) \
  switch(function(x)) { \
    case ERROR: \
      fprintf(stderr, "Error!\n"); \
      break; \
  }

Normalement, je n'ai jamais capturer la sortie de fonction et cela fonctionne bien. Mais j'ai trouvé quelques cas où j'ai aussi besoin de la valeur de retour de function(). J'ai essayé quelque chose comme ce qui suit, mais cela produit une erreur de syntaxe.

#define my_function(x) \
  do { \
    int __err = function(x); \
    switch(__err) { \
      case ERROR: \
        fprintf(stderr, "Error!\n"); \
        break; \
    } \
    __err; \
  } while(0)

Je pourrais déclarer une variable globale pour contenir la valeur de retour de la fonction, mais qui semble laid et mon programme est multithread, donc c'est probablement pour causer des problèmes. J'espère qu'il y a une meilleure solution là-bas.

  • Pourquoi ne pas faire une fonction en ligne?
  • La "sortie" d'une fonction n'est pas la même que la "valeur de retour" d'une fonction. Vous voulez que la valeur de retour.
  • Votre post est manquant plusieurs de continuation de ligne de marqueurs. C'est peut être ton erreur de syntaxe.
InformationsquelleAutor Michael Mior | 2010-08-20
  1. 6

    C'est relativement compliqué de code, il n'y a pas beaucoup de raisons de l'avoir dans une macro. Faire inline (C99) ou static (C89) ou les deux si vous voulez vraiment le placer dans un fichier d'en-tête. Avec toute raisonnable compilateur ensuite, cela devrait se traduire dans la même efficacité qu'une macro.

    • Une fonction inline, malheureusement, ne peut pas faire de quelques-uns des trucs que d'une macro, comme la concaténation des identifiants (FOO ## _size de certains code généré, je suis en utilisant, par exemple). Sinon, oui, veuillez utiliser les fonctions inline.
    • Une autre chose utile fonction inline ne peut pas le faire est en pleine expansion __FILE__ et __LINE__ macro pour générer de message d'erreur où l'erreur s'est réellement passé. De Plus, personnellement, je trouve les réponses de dire aux gens de ne pas faire les choses qu'ils demandent un moyen pour inutile car ils ne réponds pas vraiment à la question. Si vous répondez à une question, répondre à la question. Tous les commentaires sur la question qui devrait venir qu'après la réponse à la question ou tout simplement un commentaire.
    • Je pense qu'il vous manque le point. La question est de retourner une valeur à partir de telles constructions. C'est une fonctionnalité que vous ne pouvez pas avoir avec des macros seul dans la norme C. Mais rien ne les empêche de vous envelopper d'une macro autour de cette fonction aussi faire face à __LINE__ etc
    • Lorsque vous enroulez une macro autour de la fonction, n'avez-vous pas revenir en arrière à l'original d'un problème où vous ne pouvez pas retourner la valeur de la macro expression? La seule façon dont je le vois travailler avec fonction inline est en passant __LINE__ comme argument à la fonction inline, ce qui résulte en un peu laid code à mon humble avis.
    • Comme pour la déclaration des expressions, il semble gcc, clang et intel c soutenons tous. Depuis MSVC ont renoncé à C99 pour les années de toute façon, il est peu probable que la portabilité marteau si vraiment vous avez un projet C.
    • il semble que vous avez complètement sous-estimer combien de différents compilateurs C sont là.
    • faire ceci directement dans l'appel serait, en effet, être laid, oui. C'est pourquoi je tiens à envelopper l'un de ces appels dans une macro qui ajoute __LINE__, __FILE__ ou __func__. Ce serait complètement portable, de type sécuritaire et efficace. Et s'il vous plaît tous les gars de vote de cela, revenir à la question qui est traitée ici. Il n'y a rien sur ces macros dans la question.

    InformationsquelleAutor Jens Gustedt
  2. 47

    GCC dispose d'une fonction appelée déclaration des expressions

    Donc si définir la macro comme

    #define FOO(A) ({int retval; retval = do_something(A); retval;})

    que vous pourrez utiliser comme comme

    foo = FOO(bar);
    • C'est ce que j'essayais de faire avec ce qui précède. Je pense que @Jens a raison de dire qu'une fonction en ligne le mieux adapté à mes besoins.
    InformationsquelleAutor qrdl
  3. 4

    Un très retard de réponse. Mais n'en est pas moins. Je suis d'accord fonctions inline sont mieux, mais les MACROs offrent une jolie impression de plaisir que vous ne pouvez pas obtenir avec les fonctions inline. Je suis d'accord avec @qrdl que vous pouvez en effet utiliser déclaration expressions vous avait restructuré vos déclarations un peu. Voici comment cela pourrait fonctionner avec une macro -

    #define my_function(x, y) ({ \
  int __err = 0; \
  do { \
    __err = function(x, y); \
    switch(__err) { \
      case ERROR: \
        fprintf(stderr, "Error!\n"); \
        break; \
    } \
  } while(0); \
  __err; \
})
    InformationsquelleAutor linuxmonk
  4. 2

    Désolé, c'est un montage...

    1. Je pense que vous avez juste besoin d'accolades. Pas besoin de le faire..alors que les mots-clés
    2. Assurez-vous que les barres obliques inverses sont les derniers caractères de chaque ligne (pas d'espace après).
    3. Si vous avez besoin pour obtenir le tre la valeur de la macro, vous pouvez simplement ajouter un paramètre

    Comme suit:

     #define my_function(x, out) \
      { \
        int __err = function(x); \
        switch(__err) { \
          case ERROR: \
            fprintf(stderr, "Error!\n"); \
            break; \
        } \
        __err; \
        (*(out)) = _err; \
      }

    À préserver le passage par référence en C paradigme, vous devriez appeler my_function de cette façon:

    int output_err;

my_function(num, &output_err);

    De cette façon, plus tard, si vous décidez de faire my_function une fonction réelle, vous n'avez pas besoin de modifier l'appel des références.

    Btw, qrdl de la "Déclaration des Expressions" est aussi une bonne façon de le faire.

    InformationsquelleAutor hopia
  5. -2

    il n'est pas nécessaire de déclarer la variable si votre fonction retourne quelque chose, alors vous pouvez obtenir directement cette valeur. Par exemple:

    #define FOO(A) do_something(A)

    Ici faire_quelque_chose certains retours entier. Ensuite, vous pouvez facilement l'utiliser comme:

    int a = FOO(a);
    • Cela ne fonctionne pas dans mon cette situation étant donné que la macro doit également utiliser la sortie de do_something et le seul moyen de prendre l'approche que vous êtes suggère, c'est d'appeler do_something deux fois.
    InformationsquelleAutor The joker