Master Essential C Language Features: Bitwise Ops, Macros, Conditional Compilation, and More

1. Bitwise Operations

Bitwise operators work directly on the binary representation of integer values. They are essential for low‑level programming, flag manipulation, and performance‑critical code.

AND (&) : Keeps bits that are set in both operands. Example: 1010 & 1100 = 1000 OR (|) : Sets bits that are set in either operand. Example: 1010 | 1100 = 1110 XOR (^) : Sets bits that differ between operands. Example: 1010 ^ 1100 = 0110 NOT (~) : Inverts each bit. Example: ~1010 = 0101 Left shift (<<) : Shifts bits left, inserting zeros on the right. Example: 1010 << 1 = 0100 Right shift (>>) : Shifts bits right; for unsigned types zeros are inserted, for signed types the sign bit is replicated. Example:

1010 >> 2 = 0010

2. Macro Definitions

The #define preprocessor directive creates a symbolic constant or macro that is substituted before compilation. #define TEMP 10 // TEMP will be replaced by 10 Typical usage with an include file:

#include <stdio.h>
#define TEMP 10
int main() {
    int num = TEMP;
    printf("%d
", num);
    return 0;
}

The compiler replaces every occurrence of TEMP with 10, improving readability and allowing a single change to affect the whole program.

3. Conditional Compilation

Conditional compilation includes or excludes code blocks based on compile‑time expressions using directives such as #ifdef, #ifndef, #if, #elif, #else, and #endif. #ifdef: Compile the following block if the identifier is defined. #ifndef: Compile the block if the identifier is not defined. #if: Evaluate an expression; compile the block if the result is non‑zero. #elif: Else‑if for additional conditions. #else: Compile when previous conditions are false. #endif: End the conditional block.

Common pattern – a header guard:

#ifndef _LED_H
#define _LED_H

void LED_init(void);

#endif // _LED_H

This technique enables building different program variants from the same source tree.

4. extern Variable Declaration

The extern keyword declares a variable or function that is defined in another translation unit, allowing shared global symbols across multiple source files.

// file1.c
int num = 10;

// file2.c
extern int num; // refers to the definition in file1.c

During linking, both references resolve to the same memory location.

5. typedef Type Alias

typedef

creates a new name for an existing type, improving code readability and portability.

typedef unsigned char uint8_t; // alias for unsigned char
typedef uint8_t u8;            // alias for uint8_t

6. Structures

Structures group heterogeneous data members into a single composite type, which is useful for representing complex objects such as hardware configurations.

struct Student {
    char name[50];
    int age;
    float gpa;
};

Example: configuring a timer on an STM32F4 microcontroller.

#include "stm32f4xx.h"

typedef struct {
    TIM_TypeDef *timerInstance; // pointer to the timer peripheral
    uint32_t period;            // timer period in microseconds
} TimerConfig;

void configureTimer(TimerConfig *config) {
    // Enable the timer clock
    if (config->timerInstance == TIM2) {
        RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
    }
    // Set up timer base parameters
    TIM_TimeBaseInitTypeDef TIM_InitStruct;
    TIM_InitStruct.TIM_Prescaler = 8400 - 1; // 1 µs tick (assuming 84 MHz APB1)
    TIM_InitStruct.TIM_CounterMode = TIM_CounterMode_Up;
    TIM_InitStruct.TIM_Period = config->period - 1;
    TIM_InitStruct.TIM_ClockDivision = 0;
    TIM_TimeBaseInit(config->timerInstance, &TIM_InitStruct);
    // Start the timer
    TIM_Cmd(config->timerInstance, ENABLE);
}

int main(void) {
    TimerConfig timer2Config;
    timer2Config.timerInstance = TIM2;
    timer2Config.period = 1000000; // 1 second (1 000 000 µs)
    configureTimer(&timer2Config);
    while (1) {
        // Application code
    }
    return 0;
}

The TimerConfig struct bundles the peripheral pointer and period, making the configuration function clean and reusable.

7. static Storage Class

The static keyword gives a variable or function internal linkage and static storage duration, meaning the object persists for the lifetime of the program.

int counter(void) {
    static int n = 0; // initialized once
    n++;
    return n; // returns 1, 2, 3, ... on successive calls
}

Static variables are useful for maintaining state without exposing global symbols.