42 Abu Dhabi

ft_printf

Custom Printf Function Implementation

3 weeks

Individual Project

CVariadic FunctionsString ManipulationMemory Management

A complete reimplementation of the standard C printf function, focusing on format specifier parsing, variadic functions, and string formatting to understand low-level programming concepts.

Source Code

Key Features

Format Specifiers

Implemented support for %c, %s, %p, %d, %i, %u, %x, %X, and %% format specifiers with proper type handling.

Variadic Arguments

Utilized va_list, va_start, va_arg, and va_end macros to handle variable number of arguments dynamically.

String Formatting

Developed robust string formatting logic with proper width, precision, and flag handling for various data types.

Memory Efficiency

Optimized memory usage and implemented efficient string building techniques for large formatted outputs.

Development Journey

Phase 1

Function Structure Design

Designed the basic structure for ft_printf with variadic argument handling and format specifier parsing foundation.

Phase 2

Format Specifier Implementation

Implemented core format specifiers (%c, %s, %d, %i, %u) with proper type conversion and validation.

Phase 3

Advanced Specifiers

Added support for hexadecimal (%x, %X) and pointer (%p) format specifiers with proper formatting.

Challenges & Solutions

Variadic Function Handling

Problem:

Understanding and implementing variadic functions to handle unknown number of arguments with proper type safety.

Solution:

Studied va_list implementation and created a robust argument parsing system with proper type casting and memory management.

Format Specifier Parsing

Problem:

Creating a parser that correctly identifies and processes different format specifiers while maintaining printf compatibility.

Solution:

Implemented a state machine-based parser that handles nested format specifications and edge cases with comprehensive testing.

Memory Management

Problem:

Ensuring efficient memory usage while building formatted strings and handling large outputs.

Solution:

Optimized string building techniques and implemented proper memory allocation strategies for scalable performance.

ft_printf.c

// Main ft_printf function with variadic arguments
int ft_printf(const char *format, ...)
{
    va_list args;
    int count;
    int i;

    va_start(args, format);
    count = 0;
    i = 0;
    
    while (format[i])
    {
        if (format[i] == '%')
        {
            i++;
            count += parse_format_specifier(format[i], args);
        }
        else
        {
            ft_putchar(format[i]);
            count++;
        }
        i++;
    }
    
    va_end(args);
    return (count);
}

// Format specifier parser
int parse_format_specifier(char specifier, va_list args)
{
    int count;

    count = 0;
    if (specifier == 'c')
        count += print_char(va_arg(args, int));
    else if (specifier == 's')
        count += print_string(va_arg(args, char *));
    else if (specifier == 'd' || specifier == 'i')
        count += print_decimal(va_arg(args, int));
    else if (specifier == 'u')
        count += print_unsigned(va_arg(args, unsigned int));
    else if (specifier == 'x')
        count += print_hex_lower(va_arg(args, unsigned int));
    else if (specifier == 'X')
        count += print_hex_upper(va_arg(args, unsigned int));
    else if (specifier == 'p')
        count += print_pointer(va_arg(args, void *));
    else if (specifier == '%')
        count += print_char('%');
        
    return (count);
}

Previous Next