Macros - the pros and cons

[notthecheatr]

This was originally going to be a reply in my "Why OOP?" topic, talking about efficiency in loops, but I decided to make it a whole topic on its own.


One interesting way to make a pretense of using procedures when in reality doing no such thing is to use macros 

Code: Select All | Copy To Clipboard

#macro MOVE_PARTICLE_TO(particle, x, y)
  particle._x = x
  particle._y = y
#endmacro

Type pticle
  As Integer _x, _y
End Type

Dim As pticle myparticle

MOVE_PARTICLE_TO(myparticle, 0, 0)
Print myparticle._x
Print myparticle._y
MOVE_PARTICLE_TO(myparticle, 23, 42)
Print myparticle._x
Print myparticle._y

Sleep

This can be used in loops without slowing things down, since it's not really a function call at all.  The one downside is that you don't have type checking, meaning you could do really weird things like

Code: Select All | Copy To Clipboard

MOVE_PARTICLE_TO("this is a string, not a particle!!!", "hi, guys!", "this is a totally invalid place to move the particle to!  it's not even a number!")

where you pass arguments that are the wrong type and get weird errors for seemingly innocent lines of code.  Even worse, the first argument to the macro can be any type that has public members _x and _y - so for example, I could do

Code: Select All | Copy To Clipboard

Type myrandomthing
  As String _x, _y
End Type

Dim As myrandomthing someObj

MOVE_PARTICLE_TO(someObj, "Hello, ", "World!")

Print someObj._x
Print someObj._y

Sleep

and it will compile just fine despite the fact that the object and parameters to the macro have nothing to do with particles or even positions.  Such is the facts of life when using the preprocessor, which does nothing more than a simple string replace and converts the above code to:

Code: Select All | Copy To Clipboard

Type myrandomthing
  As String _x, _y
End Type

Dim As myrandomthing someObj

someObj._x = "Hello, "
someObj._y = "World!"

Print someObj._x
Print someObj._y

Sleep

which is of course perfectly valid, if odd, code.

Despite the weirdness, macros do have their uses, and keeping things fast (while somewhat clean-looking, as long as you're careful with it) could be one of them.

[KristopherWindsor]

You can look at the macros at the top of the source code file for UnAlien for a good example. The code works on objects of several different types, so in previous programs, I had essentially copied and pasted that macro code several times throughout my code.

[Lachie Dazdarian]

Again, very well explained. I'll think about using them. Thanks.

[dabooda]

Just my 2c's but macros should be kept really short and sweet also. Because you are throwing them directly into code and will have weird bugs if you aren't careful. Again notthecheater great job on the explanation.

DaBooda out...

[Pritchard]

Macros are evil.

[BadMrBox]

Why so Pritch? Why so? I dont find any use for it as for now, as for OOP. But why do you consider it evil?

[nkk_kan]

again! interesting and illuminating!!   

but one little question....why do we have to use those underscores and where to use them?

[KristopherWindsor]

but one little question....why do we have to use those underscores and where to use them?

You don't need them; they are just characters in the variable names.

[nkk_kan]

like..for differentiating them?...
one more question...the variables used in a macro are always scoped to the macro only or are they global?

[notthecheatr]

Macros are evil.

I understand why you think this, but I don't think macros are always evil.  I do think they can be overused or used inappropriately (to tell the truth I have never once used them in any actual code I've written, other than for testing purposes), and as this whole post tries to explain, there are some major disadvantages/unsafe things about using them, but I think there are some valid reasons for using them.  Like everything else, the preprocessor exists for a reason and it makes some things a lot easier (while I don't perfectly understand it yet, I think the way they are used in the fbext library makes a lot of things much simpler than they otherwise would be).  There are upsides and downsides to everything...