12. UART Write Overloading

In C, every function must have a unique name (e.g., print_int, print_string, print_float).

In C++, Function Overloading allows multiple functions to share the same name, provided they have different parameter lists (number or types of arguments).

The compiler decides which function to call at compile time based on the arguments passed. This is known as Static Resolution.

Syntax & Usage

1. Basic Overloading

You can define multiple versions of a log() function to handle different data types cleanly.

void log(int val) {
    // Code to print integer to UART
}

void log(const char* msg) {
    // Code to print string to UART
}

void log(double val) {
    // Code to print float to UART
}

// Usage
log(100);       // Calls log(int)
log("Error");   // Calls log(const char*)
log(3.14);      // Calls log(double)

2. Overloading by Number of Arguments

Useful for providing default behaviors or extended options.

// Initialize timer with default prescaler
void timer_init(int period_ms);

// Initialize timer with specific prescaler
void timer_init(int period_ms, int prescaler);

How It Works: Name Mangling

C++ supports this by "mangling" the function names. The compiler adds information about the parameters to the internal symbol name.

Note: This is why you must use extern "C" when calling C functions from C++ (to stop mangling).

Relevance in Embedded/Firmware

1. Cleaner HAL/Driver APIs

Instead of remembering uart_send_byte, uart_send_array, uart_send_string, you simply use uart.send(). The compiler picks the right driver function for you.

serial.print(10);      // Easy to read
serial.print("Hello"); // Consistent interface

2. Constructor Overloading

A peripheral driver can have multiple constructors to support different initialization modes (e.g., one for default settings, one for custom pins).

// Default I2C (uses standard pins)
I2C_Driver sensor_bus; 

// Remapped I2C (uses custom pins)
I2C_Driver sensor_bus(PB_9, PB_8); 

3. Type-Safe Alternatives to void*

In C, generic handlers often take void* and size, requiring unsafe casting. Overloading lets you write specific, type-safe handlers for int, struct, or float without casting.

Common Pitfalls (Practical Tips)