Les macros à quoi ça sert?

[Ollivier]

La différence entre une macro et une procédure?

Une procédure n'est compilée qu'une seul fois et peu t’être appelée à divers
endroits du programme.

Une macro est compilée à chaque appel
Les procédures sont donc préférables aux macros.

Bonjour Microdevweb,

Ce n'est pas exactement cela.

Une procédure n'est compilée qu'une seule fois et peut être appelée à divers
endroits du programme.

Vrai. La précision est de l'appeler APRES sa déclaration OU APRES sa description.

Une macro est compilée à chaque appel

Moins vrai. Voici une suggestion:

Le contenu d'une macro est inséré en lieu et place de son invocation, au seul moment de la compilation.

C'est comme inclure un fichier source.

Si tu inclus plusieurs fois le même fichier, tu risques un problème de confusions de tout objet nommable au sein du langage (constantes, variables, procédures, etc...).

Heureusement, il y a MacroExpandedCount qui agit comme un Sélectionner/Remplacer par un nombre, plus précisément le nombre de fois que la macro accueillant cette directive aura été invoquée.

Les procédures sont donc préférables aux macros.

Cela serait un résultat de vote. Et je crois que beaucoup d'éliseurs ne se bougerait même pas pour informer leur choix.

En théorie, tout ce qu'une procédure permet, un système de macros le permet aussi.

En pratique, c'est d'abord le pré-processeur interne qui limite les effets possibles des combinaisons de macros compilables.
Il trouve parfois des récursivités infinies qui n'y sont pas, se rigidifient au point d'être allergique à un oubli d'espace, un nombre d'instructions trop important par ligne, etc...
Donc, ça semble impossible.

Seulement Fred a fait un compilateur téléguidable. Tu peux faire un serveur qui t'envoie la syntaxe d'une instruction par sms, si ça t'enchante.

En moins de 500 lignes, un convertiseur texte/texte fait office de très bon préprocesseur, qu'importe le temps.

C'est donc possible. Une procédure n'est qu'un objet de plus pour une 'macro' limitée par les seules vraies récursivités, et plus précisément une procédure est un système d'économie de programmation qui, en ce langage, permet de s'éviter de réfléchir aux protections de données procédurales et de s'éviter de réfléchir à la compatibilité (DLLs, etc...). C'est une meta-macro à Fred (et son équipe).

[Ollivier]

J'entends par "protection de données" :
"visibilité"
(Définissable avec les directives Define, Global, Protected, Shared et Static)

[djes]

Ouf, Ollivier a corrigé cette erreur à propos de la compilation.

Microdevweb> simple suggestion, tu devrais peut-être corriger un peu ton premier post pour les débutants qui te lisent...

[PAPIPP]

Bonjour à tous

J’utilise sans réserve les macros au point que j’en ai placées dans le répertoire Residents afin de les avoir toujours sous la main.
(dans les modules elles sont disponibles dans tout l’espace de programmation ce qui n’est pas le cas des macros placées dans un module)
Pour la plus part ce sont des macros pour débugger en dynamique un programme ou une procédure.
Par exemple si vous désirez connaitre le contenu de plusieurs variables numériques avec leur nom et le numéro de ligne où elles ont été prélevées
Voila 3 macros.

Code : Tout sélectionner

Macro _q_t_
"
EndMacro

Macro _n (__n)
_q_t_#__n#=_q_t_+Str(__n)+" "
EndMacro

Macro _NL
"N°L=" + Str(#PB_Compiler_Line) + " ** "
EndMacro

elles peuvent être utilisées dans un prg de la façon suivante.

Debug _nl+_n(nomvariable1)+_n(nomvariable2)+_n((nomvariable3)….etc

Et à un autre endroit du prg la même ligne.

Debug _nl+_n(nomvariable1)+_n(nomvariable2)+_n((nomvariable3)….etc

La macro _nl me donnera le numéro de la ligne et les autre instructions _n(..) les variables x et à chacune son nom le tout sur la même ligne.

Voici à titre d’exemple une autre utilisation des macros.

Suite au post http://www.purebasic.fr/french/viewtopi ... =1&t=15442

Comme l’instruction de tri sur tableau SortStructuredArray(Tableau(), #PB_Sort_Ascending, OffsetOf(Test\Champs1), #PB_Integer)
N’est pas un tri stable c’est a dire si l’on donne deux ordres de tri sur deux champs différents.
Le tri relatif du premier ordre est détruit par le second ordre (voir le détail dans le post).
Parmi les algos de tri il en existe au moins trois qui sont stables. J’ai choisi le tri à bulle,
le plus simple, l’un des moins rapide mais le plus stable pour réaliser un module de tri très stable.

Voici le prg le plus optimisé et aussi le plus généralisé ou le plus banalisé que j'ai pu réaliser.

Il est utilisable dans un même prg principal pour travailler sur plusieurs structures de tables différentes

Dans ce PRG il y a 2 macros principales.
La première MAC_INITPROC(struct_) qui contient une procédure permet de modifier extérieurement le nom de la procédure et la structure du tableau avec lequel elle va travailler.
Ceci permet de réaliser plusieurs tris sur des tableaux de structures différentes.

La deuxième MAC_compare_(test_) simplifie la programmation car pour généraliser et banaliser une procédure de tri
il faut tenir compte du type de tri ascendant ou descendant.
En suite il faut tenir compte du type de champ sur lequel le tri est ordonné.
La combinatoire nous donne 2 ordres de tri et 11 types de champs sans compter dans le champ string les options :
#PB_Ascii : Format ASCII., #PB_UTF8 : Format UTF-8. #PB_Unicode: Format Unicode.
Qui ferait 13 types donc au total 13*2=26 possibilités de trier un tableau et donc 26 fois les instructions de la macro MAC_compare_(test_).
Ici j’ai pris par défaut le format ASCII ce qui limite à 22 possibilités de tri.
Vous pouvez ajouter les deux autres options pour vos besoins personnels.

Code : Tout sélectionner

Structure TEST
  Nom.s
  Champs1.i
  Champs2.d
EndStructure
Global maxt=200
Dim Tableau.Test(MAXT)
Structure TEST2
  Nom2.s
  Taille2.i
  date2.q
EndStructure
Dim Tableau2.Test2(MAXT)

;********************** Toutes les macros et la procedure TRIBULLE font un tout **********************
Macro MAC_compare_(test_)
  Repeat
    hasChanged=#False
    itemCount-1
    For i=0 To itemCount
      If Bool(test_)
        CopyMemory(TAB(i),*Mem,LongTerm)
        CopyMemory(TAB(i+1),TAB(i),LongTerm)
        CopyMemory(*Mem,TAB(i+1),LongTerm)
        hasChanged=#True
      EndIf 
    Next
  Until hasChanged=#False
EndMacro

Macro MAC_INITPROC(struct_)
  Procedure TRIBULLE#struct_(Array TAB.struct_(1),Offset,Type,ascdesc)
    Protected i,itemCount,hasChanged,LongTerm,*mem
    itemCount=ArraySize(TAB())
    LongTerm=TAB(1)-TAB(0)
    *mem=AllocateMemory(Longterm,#PB_Memory_NoClear)
    Select ascdesc
        ;********************************  cas du tri ascendant ******************************
      Case #PB_Sort_Ascending
        Select Type
          Case #PB_Byte    ; Le champ de la Structure est un octet (.b)
            MAC_compare_(PeekB(tab(i)+offset)>PeekB(TAB(i+1)+offset))
          Case #PB_Word    ; Le champ de la Structure est un word (.w)
            MAC_compare_( PeekW(tab(i)+offset)>PeekW(TAB(i+1)+offset))
          Case #PB_Long    ; Le champ de la Structure est un long (.l)
            MAC_compare_( PeekL(tab(i)+offset)>PeekL(TAB(i+1)+offset))
          Case #PB_String  ; Le champ de la Structure est un string (.s ou $)
                           ; Les strings fixe (fixed strings) ne sont pas supportées)
                           ;           Resultat$ = PeekS(*Memoire [, Longueur [, Format]])
                           ;           Format
                           ;           #PB_Ascii  : Format ASCII.
                           ;           #PB_UTF8   : Format UTF-8.
                           ;           #PB_Unicode: Format Unicode.
                           ;     Par défaut ascii
            MAC_compare_( PeekS(PeekL(tab(i)+offset))>PeekS(PeekL(tab(i+1)+offset)))
          Case #PB_Float    ; Le champ de la Structure est un flottant (.f)
            MAC_compare_( PeekF(tab(i)+offset)>PeekF(TAB(i+1)+offset))
          Case #PB_Double  ; Le champ de la Structure est un double (.d)
            MAC_compare_( PeekD(tab(i)+offset)>PeekD(TAB(i+1)+offset))
          Case #PB_Quad    ; Le champ de la Structure est un quad (.q)
            MAC_compare_( PeekQ(tab(i)+offset)>PeekQ(TAB(i+1)+offset))
          Case #PB_Character:; Le champ de la Structure est un caractère (.c)
            MAC_compare_( PeekC(tab(i)+offset)>PeekC(TAB(i+1)+offset))
          Case #PB_Integer ; Le champ de la Structure est un integer (.i)
            MAC_compare_(PeekI(tab(i)+offset)>PeekI(TAB(i+1)+offset))
          Case #PB_Ascii   ; Le champ de la Structure est un caractère ascii (.a)
            MAC_compare_( PeekA(tab(i)+offset)>PeekA(TAB(i+1)+offset))
          Case #PB_Unicode ; Le champ de la Structure est un caractère unicode (.u)
            MAC_compare_( PeekU(tab(i)+offset)>PeekU(TAB(i+1)+offset))
        EndSelect
        ;********************************  cas du tri descendant ******************************
      Case #PB_Sort_Descending
        Select Type
          Case #PB_Byte    ; Le champ de la Structure est un octet (.b)
            MAC_compare_( PeekB(tab(i)+offset)<PeekB(TAB(i+1)+offset))
          Case #PB_Word    ; Le champ de la Structure est un word (.w)
            MAC_compare_( PeekW(tab(i)+offset)<PeekW(TAB(i+1)+offset))
          Case #PB_Long    ; Le champ de la Structure est un long (.l)
            MAC_compare_( PeekL(tab(i)+offset)<PeekL(TAB(i+1)+offset))
          Case #PB_String  ; Le champ de la Structure est un string (.s ou $)
                           ; Les strings fixe (fixed strings) ne sont pas supportées)
                           ;           Resultat$ = PeekS(*Memoire [, Longueur [, Format]])
                           ;           Format
                           ;           #PB_Ascii  : Format ASCII.
                           ;           #PB_UTF8   : Format UTF-8.
                           ;           #PB_Unicode: Format Unicode.
                           ;     Par défaut ascii
            MAC_compare_( PeekS(PeekL(tab(i)+offset))<PeekS(PeekL(tab(i+1)+offset)))
          Case #PB_Float    ; Le champ de la Structure est un flottant (.f)
            MAC_compare_( PeekF(tab(i)+offset)<PeekF(TAB(i+1)+offset))
          Case #PB_Double  ; Le champ de la Structure est un double (.d)
            MAC_compare_( PeekD(tab(i)+offset)<PeekD(TAB(i+1)+offset))
          Case #PB_Quad    ; Le champ de la Structure est un quad (.q)
            MAC_compare_( PeekQ(tab(i)+offset)<PeekQ(TAB(i+1)+offset))
          Case #PB_Character:; Le champ de la Structure est un caractère (.c)
            MAC_compare_( PeekC(tab(i)+offset)<PeekC(TAB(i+1)+offset))
          Case #PB_Integer ; Le champ de la Structure est un integer (.i)
            MAC_compare_( PeekI(tab(i)+offset)<PeekI(TAB(i+1)+offset))
          Case #PB_Ascii   ; Le champ de la Structure est un caractère ascii (.a)
            MAC_compare_( PeekA(tab(i)+offset)<PeekA(TAB(i+1)+offset))
          Case #PB_Unicode ; Le champ de la Structure est un caractère unicode (.u)
            MAC_compare_( PeekU(tab(i)+offset)<PeekU(TAB(i+1)+offset))
        EndSelect
    EndSelect
  EndProcedure
EndMacro  

;********************** Fin de toutes les macros et de la procedure TRIBULLE **********************



Procedure RandomSign()
  ProcedureReturn Random(1)*2-1
EndProcedure


For I=0 To MAXT
  Tableau(I)\Champs1=Random(9,0)*RandomSign()
  Tableau(I)\Champs2=Random(1000,100)*RandomSign()
  tableau(i)\Nom="Dupond Pierre Jean Simon"+RSet(Str(Random(MAXt,0)),3,"0")
Next
; For I = 0 To MAXT
;   Debug RSet(Str(Tableau(I)\Champs1), 3, " ") + "=> " + RSet(Str(Tableau(I)\Champs2), 4, "0")+ "  "+tableau(I)\Nom
; Next
Debug "********************  Apès Tri"
MAC_INITproc(TEST) ; Donnez le nom de la structure au tableau de la procedure TRIBULLE donne comme nom de procédure TRIBULLEtest
                   ; TRIBULLE(tableau(),OffsetOf(test\Champs1),TypeOf(test\Champs1),#PB_Sort_Descending)
                   ; TRIBULLE(tableau(),OffsetOf(test\Champs1),TypeOf(test\Champs1),#PB_Sort_Ascending)
                   ; TRIBULLE(tableau(),OffsetOf(test\Nom),TypeOf(test\Nom),#PB_Sort_Ascending)
                   ; TRIBULLE(tableau(),OffsetOf(test\Nom),TypeOf(test\Nom),#PB_Sort_Descending)
                   ; TRIBULLE(tableau(),OffsetOf(test\Champs2),TypeOf(test\Champs2),#PB_Sort_Descending)
TRIBULLEtest(tableau(),OffsetOf(test\Champs2),TypeOf(test\Champs2),#PB_Sort_Ascending)
TRIBULLEtest(tableau(),OffsetOf(test\Champs1),TypeOf(test\Champs1),#PB_Sort_Ascending)
For I=0 To MAXT
  Debug RSet(Str(Tableau(I)\Champs1),3," ")+"=> "+RSet(Str(Tableau(I)\Champs2),4,"0")+"  "+tableau(I)\Nom
Next
Debug " ******************  Deuxième Procédure avec pour structure test2 *************** "
For I=0 To MAXT
  Tableau2(I)\Taille2=Random(220,120)
  Tableau2(I)\date2=Date(Random(2018,1970),Random(12,1),Random(28,1),0,0,0)
  tableau2(i)\Nom2="Dupond2 Pierre Jean Simon"+RSet(Str(Random(MAXt,0)),3,"0")
Next
MAC_INITproc(test2) ; Donnez le nom de la structure au tableau de la procedure TRIBULLE donne comme nom de procédure TRIBULLEtest2
TRIBULLEtest2(tableau2(),OffsetOf(test2\date2),TypeOf(test2\date2),#PB_Sort_Descending)
TRIBULLEtest2(tableau2(),OffsetOf(test2\Taille2),TypeOf(test2\Taille2),#PB_Sort_Ascending)
masque$="%yyyy/%mm/%dd"
For I=0 To MAXT
  Debug RSet(Str(Tableau2(I)\Taille2),4," ")+"=> "+ FormatDate(Masque$, Tableau2(I)\date2)+"  "+tableau2(I)\Nom2
Next

A+

[microdevweb]

@Ollivier,

Je me suis peut'être mal exprimé. La macro est compilée à chaque appel elle revient comme encodé sont contenu. Si ce n'est pas le cas, alors je n'ai rien compris au macros et je demande à un modérateur d'avoir l'obligeance de supprimer ce post pour ne pas induire en erreur les membres de ce forum.

[Ollivier]

@MicroDevWeb

ce n'est pas grave au point de le supprimer. Autant le déplacer. Tu t'es risqué pour quelque chose de complexe.

[Mesa]

Les macros à quoi ça sert ?
A plus grand chose.

Leurs présence s'explique surtout pour des raisons historiques car elles ont peu d'utilité aujourd'hui, même si elles peuvent dépanner dans des circonstances très particulières (actions répétitives).

Les "vieux" programmeurs les utilisent encore.
Ceux qui ont connu le temps où la souris n'existait pas et encore moins le copier-coller. Dans ces conditions, taper une macro allégeait un peu le travail du programmeur, surtout du programmeur en assembleur où les macro sont apparus comme pseudo instruction du compilateur.

Elles ont survécus à l'ancêtre du presse-papier sous turbopascal de Borland avec ses fonctions "Block" de son éditeur, survécu au presse-papier, à la souris, aux procédures et autres fonctions.

Voilà pourquoi elles existent toujours, essentiellement à cause de l'habitude.

Le "style de programmation" avec Macro se perd.

Mesa.

[falsam]

Mode

Les macros à quoi ça sert ? A plus grand chose.

Tu veux voir mon macro crétin ? haha

[PAPIPP]

Bonjour Mesa

Remarques d’un vieux programmeur
Je suppose que c’est toi qui à traduit la fonction Macros suivante en Anglais par la traduction suivante en Français.
Texte de la doc en Anglais

Macros

Syntax
Macro <name> [(Parameter [, ...])]
...
EndMacro
Description
Macros are a very powerful feature, mainly useful for advanced programmers. A macro is a placeholder for some code (one keyword, one line or even many lines), which will be directly inserted in the source code at the place where a macro is used. In this, it differs from procedures, as the procedures doesn&apos;t duplicate the code when they are called.

Traduit par Mesa je suppose

Syntax
Macro <nom> [(Parametre [, ...])]
...
EndMacro
Description
Le système de macro est une fonctionnalité très puissante, principalement utile pour les programmeurs chevronnés. Une macro est un bout de code quelconque (un mot clef, une ligne, plusieurs lignes) qui peut être inséré à n'importe quel endroit dans le code source en indiquant le nom de la macro. En ce sens, une macro est différente d'une procedure, car les procédures ne dupliquent pas leur code à chaque appel.

Les concepteurs de PB sont-ils assez incohérents pour écrire un concept qui se trouve en contradiction formelle avec ta remarque précédente ?

Je ne le crois pas car ils écrivent ‘very powerful feature’ et ‘advanced programmers’
Et non ’old programmers’

Il existe dans le répertoire RESISENTS de PB 540 des macros utilisées par les concepteurs de PB (pour les lister j’ai réalisé un PRG disponible sur le forum
http://www.purebasic.fr/french/viewtopi ... nt#p157897

Par ailleurs le copier coller existait avant l’invention de la souris par (SRI) utilisée en premier par XEROX et non pas par Apple comme beaucoup de personnes le pensent.
Donc les vieux programmeurs avaient déjà la possibilité de dupliquer leur texte.(Voir EDIT du DOS toujours disponible sous Window.Tapez Edit dans l'option execute. Microsoft a amélioré le produit depuis le DOS 3)

Le "style de programmation" avec Macro se perd.

Oui mais les raisons sont assez différentes de celles que tu as émises (facilité avec la pratique des nouveaux langages malgré parfois la présence de macro)
Et un manque de connaissance dans l’utilisation et le maniement des macros qui peuvent devenir assez complexes.


A+

[Ar-S]

J'ajouterai qu'avec l'apparition des BindEvent, la macro s'avère pratique aussi pour la création de gadget avec leur callback intégré.
Je trouve que ça éclairci la chose (mon 'mal' des bindevent est en train de disparaître)
Cet exemple reprend le principe de ton 1er topic microdevweb mais je le trouve plus simple à piger.

Code : Tout sélectionner

; Test de création de gadget + bindgadgetevent via macro
; Ar-S // PB 5.31 x86

Declare clic()
Declare message()
Declare EventCanvas()


; MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM

;             MACRO - BOUTON + Callback

; MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM


; Macro qui integre la création du bouton et le callback vers une procédure
Macro ButtonEventGadget(ID,x,y,l,h,titre,flag,proce)
  ButtonGadget(ID,x,y,l,h,titre,flag)
  BindGadgetEvent(ID, @proce())
EndMacro


; MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM

;             MACRO - CANVAS + Callback

; MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM

Macro CanvasEventGadget(ID,x,y,l,h, option, proce)
  CanvasGadget(ID, x, y, L, H, option)
  BindGadgetEvent(ID, @proce()) 
EndMacro





; ///////////////////////////////////////////////////////

;           PROCEDURES DES EVENTS CANVAS

; //////////////////////////////////////////////////////

Procedure EventCanvas()
  Select EventType()
    Case #PB_EventType_MouseEnter  
      
      Debug "Souris dedans"
      
      StartDrawing(CanvasOutput(2))
      C = $00CCFF 
      Box(0,0,GadgetWidth(2),GadgetHeight(2),C )
      StopDrawing()
      

      
    Case #PB_EventType_MouseLeave  
      
      Debug "Souris dehors"
      
      StartDrawing(CanvasOutput(2))
      C = $0 
      Box(0,0,GadgetWidth(2),GadgetHeight(2),C )
      StopDrawing()         
      
      
  EndSelect
  
  
  ProcedureReturn EventType()
EndProcedure



; ///////////////////////////////////////////////////////

;           PROCEDURES DES BOUTONS

; //////////////////////////////////////////////////////

; Procédure qui s'execute si clic sur le bouton 0
Procedure CliC()
  Debug "Vous avez cliqué sur le  bouton " + EventGadget()  
EndProcedure

; Procédure qui s'execute si clic sur le bouton 1
Procedure Message()
  MessageRequester ("test", "Vous avez cliqué sur le  bouton " + EventGadget(),0)  
EndProcedure





; PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP

;            PROGRAMME PRINCIPALE

; PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP


OpenWindow(0, 100, 100, 200, 200, "Test Clic", #PB_Window_SystemMenu)

ButtonEventGadget(0, 10, 10, 180, 30, "Cliquez !",0,clic)
ButtonEventGadget(1, 10, 40, 180, 30, "Cliquez !",0,message)
CanvasEventGadget(2,10,80,180,100,#PB_Canvas_ClipMouse,EventCanvas)
StartDrawing(CanvasOutput(2))
  Box(0,0,180,100,$0)
StopDrawing()


Repeat
  Event = WaitWindowEvent()
Until Event = #PB_Event_CloseWindow

[microdevweb]

Ce type de code aurait peu être réalisé en procédure.

Code : Tout sélectionner

Macro mString(Id,Label,value,EventProcedure)
      temp=TextGadget(#PB_Any,X,Y,W,H,Label)
      Y+H
      StringGadget(Id,X,Y,W,H,value)
      SetGadgetFont(temp,FontID(0))
      SetGadgetFont(Id,FontID(0))
      If EventProcedure<>-1
            BindGadgetEvent(Id,EventProcedure)
      EndIf

L'inconvénient majeure étant que les valeurs X,Y,W,H auraient du être passées en paramètres. Bien que n'utilisant les macros que depuis peut de temps, je les trouve maintenant pratique. Mais comme la dit Spock à utilisé avec modération.

[Flype]

Pour apporter un peu de précisions par rapport aux macros...

Lorsqu'on compile un programme, les macros sont traitées en premier, lors de la première passe du compilateur.
Le compilateur remplace, dans le fichier source, tous les appels à une macro par le bloc de code correspondant.
Il fait de même avec les constantes. Les constantes sont apparentées à la famille des macros.

Le résultat de la première passe du compilateur est un fichier source sans macros et sans constantes.

Exemple :

Code : Tout sélectionner

Macro DBG(a)
  Debug "Info: " + a
EndMacro

Enumeration
  #Const1 = "abcdef"
  #Const2 = 123.456
EndEnumeration

MessageRequester(#Const1, "Test")
DBG(#Const1)
DBG(#Const2)
End

Après la première passe du compilateur, le code ressemble à cà :

Code : Tout sélectionner

MessageRequester("abcdef", "Test")
Debug "Info: " + "abcdef"
Debug "Info: " + 123.456
End

Ensuite le compilateur entame la compilation à proprement dite.

Il faut bien comprendre que ce n'est que du remplacement de texte dans le fichier source, avant compilation.
Une macro ne retourne pas de résultat (elle ne fait que remplacer, encore une fois).
C'est le code contenu dans une macro qui retourne ou non un résultat.

Les macros les plus pertinantes sont celles qui tiennent sur une seule ligne et dont le code retourne un résultat.
Sur plusieurs lignes, c'est en principe à éviter car cà rend le code (beaucoup) plus complexe à lire et comprendre, et à maintenir.

Moins il en a dans un programme, mieux c'est. Ce qui n'enlève en rien leur intérêt. Il faut les utiliser à bon essient.

On utilise en principe une macro, après avoir pesé le pour et le contre par rapport à l'utilisation d'une procédure.
Le choix est fait en fonction en fonction des performances souhaitées, sachant que l'appel d'une fonction coute un peu de temps (jump, pile, ...).
Si une opération mathématique est récurrente, et que l'appel à une procédure est trop couteux dans une partie critique d'un programme (une boucle gourmande) alors on préfèrera une macro.

Le but d'une macro est d'éclaircir le code (et non le contraire) pour le programmeur, en factorisant des petites parties récurrentes de code.
Il peut servir à faire des alias de fonctions, si cà éclaircit le code mais attention aux surcouches inutiles et difficiles à maintenir.

[microdevweb]

Merci pour ce complément d'informations Flype.