Printing a variable number of arguments to a format string

To my knowledge there is no way to give a different number of arguments to printf at runtime.

Therefore you'll have to build the output string yourself.

I'll not dump all the code but only give you some ideas at high level.

#define OUT_STR_SIZE 8192

char* outStr = calloc(OUT_STR_SIZE, 1);   // Allocate an output buffer
assert(outStr  != NULL);
char* tmp = format_str;  // tmp pointer to track how much of the format string
                         // that has been handled
size_t idx = 0;          // next position in output buffer to write
size_t str_idx = 0;      // index of next string to copy when %s is found

while(*tmp)  // Loop the whole format string
{
    if (*tmp = '%' && *(tmp+1) == 's')
    {
        // Copy a string to output buffer
        strcpy(&outStr[idx], specs[str_idx]);  // Append a string from specs
        idx = idx + strlen(str_idx);
        ++str_idx;
        tmp += 2;
    }
    else
    {
        // Copy a single char to output buffer
        outStr[idx] = *tmp;
        ++idx;
        ++tmp;
    }
}
assert(count == str_idx);  // Just checking that all %s was handled

printf("%s", outStr);

free(outStr);

Bad things with the code that need to be fixed

The output string size is fixed at 8192 chars. If that's not always enough, you need to check the available space as you add new chars and use realloc when you run out of space.

The code will fail for format strings like "hello\%s%s" due to the '\'

I'll leave it as an exercise for OP to fix these things.

If you are lazy, you can do:

int func(const char *fmt, int count, const char **specs) {
    switch(count) {
    case 1: return printf(fmt, specs[0]);
    case 2: return printf(fmt, specs[0], specs[1]);
    case 3: return printf(fmt, specs[0], specs[1], specs[2]);
    // etc. for as many args you want to support
    }
}

If you are not lazy, you should parse %s formatting string on your own (for example as in the other answer).

The C standard library does not provide functions similar to printf that work on a variable number of arguments provided as an array. In order to do what you want, you would have to roll your own.

If you want to dynamically construct such a string, a good old for(...) realloc() loop is the way to go. Here's a simple implementation (it could probably be optimized more).

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

char *my_sprintf(const char *fmt, size_t n, char *const *strings) {
    const char *fmt_start, *fmt_end;
    size_t i, len, prev_len, fmt_len, spec_len;
    char *res, *tmp;

    fmt_start = fmt;
    len = 0;
    res = NULL;

    for (i = 0; i < n; i++) {
        // Find position of next %s format specifier.
        fmt_end = strstr(fmt_start, "%s");
        if (fmt_end == NULL) {
            // Error out if not found.
            free(res);
            return NULL;
        }
        
        // Do some math...
        fmt_len = fmt_end - fmt_start; // Length of current format specifier segment.
        spec_len = strlen(strings[i]); // Length of current string.
        prev_len = len;            // Previous total length.
        len += fmt_len + spec_len; // New total length.

        // Increase the size of the final string.
        tmp = realloc(res, len + 1);
        if (tmp == NULL) {
            // Error out if realloc() fails.
            free(res);
            return NULL;
        }

        res = tmp;
        
        // Copy specifier segment and i-th string at the end of the final string.
        memcpy(res + prev_len, fmt_start, fmt_len);
        memcpy(res + prev_len + fmt_len, strings[i], spec_len);
        
        // Skip current specifier.
        fmt_start = fmt_end + 2;
    }

    // Copy last specifier segment (if needed).
    
    fmt_len = strlen(fmt_start);
    prev_len = len;
    len += fmt_len;

    tmp = realloc(res, len + 1);
    if (tmp == NULL) {
        free(res);
        return NULL;
    }

    res = tmp;
    memcpy(res + prev_len, fmt_start, fmt_len);
    res[len] = '\0';

    return res;
}

int main(int argc, char **argv) {
    char *res = my_sprintf(argv[1], argc - 2, argv + 2);

    if (res != NULL) {
        puts(res);
        free(res);
    } else {
        puts("ERR");
    }

    return 0;
}

I particularly like this approach because it has a few advantages:

1. No need to know the length of the resulting string upfront, final string is dynamically allocated.
2. No need to modify any of the strings provided as argument.
3. Uses memcpy(), iterating over the whole final string twice (one time to check length, one to copy), unlike solutions involving strlen() + strcpy(), which could potentially iterate over the result three times (a common implementation for strcpy(dst, src) is memcpy(dst, src, strlen(src) + 1)).
4. Simple error checking in case the number of specifiers is not enough (you can decide what to do inside those if statements if you don't want to just return NULL.