55 lines
1.6 KiB
Markdown
55 lines
1.6 KiB
Markdown
---
|
|
tags:
|
|
- C
|
|
---
|
|
|
|
Think of macros as a find and replace that takes place before compilation at the
|
|
[pre-processor](./C_compilation_process.md) stage.
|
|
|
|
They are ephemeral and never make it into the compiled code in the form they are
|
|
defined as.
|
|
|
|
When the preprocessor injects the value, the injection happens "inline" without
|
|
having to call functions which make costly alterations to the stack, which is
|
|
the main benefit - efficiency.
|
|
|
|
Starting with a simple example:
|
|
|
|
```c
|
|
#define NAME "Thomas"
|
|
```
|
|
|
|
This is not actually a variable because it has no memory address. It never makes
|
|
it to memory-assignation because it doesn't exist after pre-processing. By the
|
|
compilation stage,j this value has been added to the code as a type
|
|
corresponding to the literal you defined; in this case a string literal
|
|
(`char *`). To emphasise, the macro itself has no type because it doesn't exist
|
|
at the type level (compilation), the data type it represents after injection is
|
|
applied by the compiler through parsing.
|
|
|
|
> The convention is to have macros in `ALL_CAPS` to distinguish them from real
|
|
> variables. Don't confuse them for constants, constants are actually written in
|
|
> lowercase like other actual variables.
|
|
|
|
To use a more complex example, a function and function call such as:
|
|
|
|
```c
|
|
int square(int x) { return x * x; }
|
|
int a = square(5);
|
|
```
|
|
|
|
Can be reduced to a macro:
|
|
|
|
```c
|
|
#define SQUARE(x) ((x) * (x))
|
|
int a = SQUARE(5);
|
|
```
|
|
|
|
Which, because it uses `#` is processed at the
|
|
[pre-processor compilation stage](./C_compilation_process.md), becomes:
|
|
|
|
```c
|
|
int a = ((5) * (5));
|
|
```
|
|
|
|
after pre-processing but before compilation.
|