C sprintf function

last modified April 6, 2025

String formatting is a crucial skill in C programming, enabling you to create formatted strings efficiently. The sprintf function is a powerful tool for this purpose, but requires careful use to avoid buffer overflows. This tutorial explains sprintf in depth, demonstrates its usage, and shows safer alternatives like snprintf. Mastering string formatting ensures robust text processing and output generation in your programs.

What Is sprintf?

The sprintf function in C writes formatted data to a string buffer. It works like printf, but stores the result in memory instead of printing to stdout. The function takes a destination buffer, format string, and optional arguments. While powerful, sprintf is unsafe as it doesn't check buffer size. Always prefer snprintf when security matters.

Basic sprintf Example

Let's start with a simple example demonstrating basic string formatting.

basic_sprintf.c

#include <stdio.h>

int main() {
    char buffer[100];
    int age = 25;
    float height = 1.75f;
    
    sprintf(buffer, "I am %d years old and %.2f meters tall.", age, height);
    
    printf("Formatted string: %s\n", buffer);
    return 0;
}

This example formats an integer and float into a string using sprintf. The format specifiers %d and %.2f control how values appear. The buffer must be large enough to hold the result. The formatted string is then printed using printf.

Formatting Multiple Values

sprintf can format multiple values of different types into a single string.

multi_format.c

#include <stdio.h>

int main() {
    char result[150];
    char name[] = "Alice";
    int score = 95;
    double average = 87.456;
    
    sprintf(result, "Student: %s\nScore: %d/100\nClass average: %.1f%%", 
            name, score, average);
    
    puts(result);
    return 0;
}

This code formats a student record with string, integer, and floating-point values. The %% in the format string produces a literal percent sign. Note the buffer size (150) is larger than the expected output to prevent overflow. The puts function prints the complete formatted string.

Safe Alternative: snprintf

The snprintf function is the safe version of sprintf.

safe_snprintf.c

#include <stdio.h>

int main() {
    char buffer[20];
    int written = snprintf(buffer, sizeof(buffer), 
                         "The answer is %d", 42);
    
    if (written >= sizeof(buffer)) {
        printf("Warning: Truncation occurred\n");
    }
    
    printf("Buffer: '%s'\n", buffer);
    printf("Characters written: %d\n", written);
    return 0;
}

snprintf takes the buffer size as second argument, preventing buffer overflows. It returns the number of characters that would be written if the buffer was large enough. This lets you detect truncation. Always use snprintf instead of sprintf in production code.

Building File Paths

sprintf is useful for constructing file paths dynamically.

file_path.c

#include <stdio.h>

int main() {
    char path[256];
    int user_id = 42;
    
    sprintf(path, "/home/user%d/data/file.txt", user_id);
    
    printf("Constructed path: %s\n", path);
    
    // Now using snprintf for safety
    snprintf(path, sizeof(path), 
            "/home/user%d/data/file.txt", user_id);
    
    printf("Safe path: %s\n", path);
    return 0;
}

This example shows how to build file paths by inserting numeric IDs. The first version uses sprintf which is risky if the buffer is too small. The second version demonstrates the safer snprintf approach. Always ensure your buffer is large enough for the worst-case scenario.

Formatting Date Strings

Create custom date formats using sprintf with date components.

date_format.c

#include <stdio.h>

int main() {
    char date_str[50];
    int year = 2025;
    int month = 4;
    int day = 6;
    
    sprintf(date_str, "%04d-%02d-%02d", year, month, day);
    
    printf("ISO date format: %s\n", date_str);
    
    // Alternative format
    sprintf(date_str, "%d/%d/%d", month, day, year);
    printf("US date format: %s\n", date_str);
    
    return 0;
}

This code formats date components into different string representations. The %04d ensures 4-digit years with leading zeros. The %02d formats months and days as two digits. The second sprintf demonstrates a different date format common in the US.

Best Practices for String Formatting

Prefer snprintf: Always use snprintf instead of sprintf for safety.
Check Buffer Size: Ensure your buffer is large enough for the worst-case output.
Validate Input: Check values before formatting to prevent unexpected results.
Handle Errors: Check snprintf return value for truncation.
Use Constants: Define buffer sizes as constants for easy maintenance.

Source

C sprintf Documentation

This tutorial has demonstrated the power and risks of sprintf, showing practical examples from basic formatting to file path construction. Remember to always prefer snprintf in production code for safer string operations.

Author

My name is Jan Bodnar, and I'm a dedicated programmer with a deep passion for coding. Since 2007, I've been sharing my expertise through over 1,400 articles and 8 e-books. With more than a decade of teaching experience, I strive to make programming accessible and engaging.

List C Standard Library.

Ebooks