How to Create a Macro in C

In this article, we go over how to create a macro in C.

A macro is a preprocessor directive which allows a programmer to make a textual replacement for some value in code.

A very simple example would be a program that calculates a mathematical function such as the area of circle, using PI.

Instead of using the value of PI for each of the area calculations, we can define PI in a preprocessor directive as a text with a value and then use this text throughout the program to represent the value of PI.

So we show how to do this in the program below.

#include <stdio.h> #define PI 3.14 int main() { printf("This is the value of PI: %f \n", PI); double circle1= PI *(3 *3); double circle2= PI * (8*8); printf("The area of the first circle is %f \n", circle1); printf("The area of the second circle is %f \n", circle2); return 0; }

Let's now review this code.

So you see we have defined a macro named PI at the top of our code before the main function.

This is a preprocessor directive which tells the compiler the value of this macro, which can later be substituted into any part of our program.

Notice how semicolons are not used to define macros.

One advantage of using macros is that you define the value once in code and can use it throughout the code. If ever the value changes, for example, with PI if you wanted to define it more precisely by adding more digits, you would just need it to change that value one place in code instead of several.

Macros are also useful for making code much more readable.

With certain codes such as when working with embedded microcontrollers, using macros can make code much more understandable and clearer.

#include <stdint.h> //Code to turn on LED at Pin 12 of PORTD when input at pin PA0 is HIGH #define GPIO_PORTD_CLOCK_ON 3 #define GPIO_PORTA_CLOCK_ON 0 #define GPIO_PORTD_PIN12_SET_AS_OUTPUT 24 #define GPIO_PORTA_PIN0_INPUT 0 #define GPIO_PORTD_PIN12_OUTPUT_STATE 12 int main(void) { uint32_t *pClkCtrlReg= (uint32_t*)0x40023830; uint32_t *pPortDModeReg= (uint32_t*)0x40020C00; uint32_t *pPortDOutReg= (uint32_t*)0x40020C14; uint32_t *pPortAModeReg= (uint32_t*)0x40020000; uint32_t *pPortAInReg= (uint32_t*)0x40020010; //This code turns on the green LED at pin 12 //Enables peripheral clock register for GPIOD (Port D) *pClkCtrlReg |= (1 << GPIO_PORTD_CLOCK_ON); //Enables peripheral clock register for GPIOA (PORT A) *pClkCtrlReg |= (1 << GPIO_PORTA_CLOCK_ON); //Sets pin 12 as output *pPortDModeReg |= (1 << GPIO_PORTD_PIN12_SET_AS_OUTPUT); //Configure PAO as input (GPIOA Mode register) *pPortAModeReg &= ~(3 << GPIO_PORTA_PIN0_INPUT); while(1) { uint8_t pinStatus= (uint8_t)(*pPortAInReg & 0x1); if(pinStatus) { *pPortDOutReg |= (1 << GPIO_PORTD_PIN12_OUTPUT_STATE); } else { *pPortDOutReg &= ~(1 << GPIO_PORTD_PIN12_OUTPUT_STATE); } } }

So you can see at the beginning we define 2 macros in order to turn on the peripheral clock registers for GPIO PORTA and PORTD.

We then define another macro that sets pin 12 of PORTD as output and another that sets pin 0 of PORTA as input.

Lastly, we create another macro that allows us to change the output state of pin 12 of PORTD, either turning it on or turning it off.

Notice how these macros help to make the code more understandable and clearer.

There's one more thing we can do with macros.

Other than just use them purely as a textual replacement for a value, we can create function-like macros, which define macros that act as functions.

Let's create a function in which a user inputs a person's weight in pounds (lbs) and outputs the weight as kilograms (kg).

The program below create a macro-like function in C that does this.

#include <stdio.h> #define weightkgs(x) ((weight)/(2.2)) int main() { double weight= 170; printf("This is the weight entered: %f \n", weight); printf("This is the weight in kilograms %f \n", weightkgs(weight)); return 0; }

So we define a function, named weightkgs(), which takes in a single parameter, the weight of a person in pounds. The function then returns the weight of the person in kilograms.

So just as you can define regular values with macros, you can do the same for functions and use these functions within your code.

So, in summary with macxros, it is best to use meaningful names when creating them, use upper case letters as a convention to distinguish them from variables.

It is important to know that macros are not variables. They do not consume any ram space during compile time of a program.

When using function-like macros, make sure to surround all values with parenthesis. This is best practice.

And this is how to create a macro in C.

Related Resources

How to Set Bits of a Number in C

How to Clear Bits of a Number in C