你是否曾经为printf之类的函数迷惑？

他们其实都是调用一个函数，侯先生说，源码面前了无秘密：

/**
 * vsnprintf - Format a string and place it in a buffer
 * @buf: The buffer to place the result into
 * @size: The size of the buffer, including the trailing null space
 * @fmt: The format string to use
 * @args: Arguments for the format string
 *
 * The return value is the number of characters which would
 * be generated for the given input, excluding the trailing
 * '\0', as per ISO C99. If you want to have the exact
 * number of characters written into @buf as return value
 * (not including the trailing '\0'), use vscnprintf. If the
 * return is greater than or equal to @size, the resulting
 * string is truncated.
 *
 * Call this function if you are already dealing with a va_list.
 * You probably want snprintf instead.
 */
int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
{
    int len;
    unsigned long long num;
    int i, base;
    char *str, *end, c;
    const char *s;

    int flags;        /* flags to number() */

    int field_width;    /* width of output field */
    int precision;        /* min. # of digits for integers; max
                 number of chars for from string */
    int qualifier;        /* 'h', 'l', or 'L' for integer fields */
                /* 'z' support added 23/7/1999 S.H. */
                /* 'z' changed to 'Z' --davidm 1/25/99 */

    /* Reject out-of-range values early */
    if (unlikely((int) size < 0)) {
        /* There can be only one.. */
        static int warn = 1;
        WARN_ON(warn);
        warn = 0;
        return 0;
    }

    str = buf;
    end = buf + size - 1;

    if (end < buf - 1) {
        end = ((void *) -1);
        size = end - buf + 1;
    }

    for (; *fmt ; ++fmt) {
        if (*fmt != '%') {
            if (str <= end)
                *str = *fmt;
            ++str;
            continue;
        }

        /* process flags */
        flags = 0;
        repeat:
            ++fmt;        /* this also skips first '%' */
            switch (*fmt) {
                case '-': flags |= LEFT; goto repeat;
                case '+': flags |= PLUS; goto repeat;
                case ' ': flags |= SPACE; goto repeat;
                case '#': flags |= SPECIAL; goto repeat;
                case '0': flags |= ZEROPAD; goto repeat;
            }

        /* get field width */
        field_width = -1;
        if (isdigit(*fmt))
            field_width = skip_atoi(&fmt);
        else if (*fmt == '*') {
            ++fmt;
            /* it's the next argument */
            field_width = va_arg(args, int);
            if (field_width < 0) {
                field_width = -field_width;
                flags |= LEFT;
            }
        }

        /* get the precision */
        precision = -1;
        if (*fmt == '.') {
            ++fmt;
            if (isdigit(*fmt))
                precision = skip_atoi(&fmt);
            else if (*fmt == '*') {
                ++fmt;
                /* it's the next argument */
                precision = va_arg(args, int);
            }
            if (precision < 0)
                precision = 0;
        }

        /* get the conversion qualifier */
        qualifier = -1;
        if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' ||
         *fmt =='Z' || *fmt == 'z') {
            qualifier = *fmt;
            ++fmt;
            if (qualifier == 'l' && *fmt == 'l') {
                qualifier = 'L';
                ++fmt;
            }
        }

        /* default base */
        base = 10;

        switch (*fmt) {
            case 'c':
                if (!(flags & LEFT)) {
                    while (--field_width > 0) {
                        if (str <= end)
                            *str = ' ';
                        ++str;
                    }
                }
                c = (unsigned char) va_arg(args, int);
                if (str <= end)
                    *str = c;
                ++str;
                while (--field_width > 0) {
                    if (str <= end)
                        *str = ' ';
                    ++str;
                }
                continue;

            case 's':
                s = va_arg(args, char *);
                if ((unsigned long)s < PAGE_SIZE)
                    s = "";

                len = strnlen(s, precision);

                if (!(flags & LEFT)) {
                    while (len < field_width--) {
                        if (str <= end)
                            *str = ' ';
                        ++str;
                    }
                }
                for (i = 0; i < len; ++i) {
                    if (str <= end)
                        *str = *s;
                    ++str; ++s;
                }
                while (len < field_width--) {
                    if (str <= end)
                        *str = ' ';
                    ++str;
                }
                continue;

            case 'p':
                if (field_width == -1) {
                    field_width = 2*sizeof(void *);
                    flags |= ZEROPAD;
                }
                str = number(str, end,
                        (unsigned long) va_arg(args, void *),
                        16, field_width, precision, flags);
                continue;


            case 'n':
                /* FIXME:
                * What does C99 say about the overflow case here? */
                if (qualifier == 'l') {
                    long * ip = va_arg(args, long *);
                    *ip = (str - buf);
                } else if (qualifier == 'Z' || qualifier == 'z') {
                    size_t * ip = va_arg(args, size_t *);
                    *ip = (str - buf);
                } else {
                    int * ip = va_arg(args, int *);
                    *ip = (str - buf);
                }
                continue;

            case '%':
                if (str <= end)
                    *str = '%';
                ++str;
                continue;

                /* integer number formats - set up the flags and "break" */
            case 'o':
                base = 8;
                break;

            case 'X':
                flags |= LARGE;
            case 'x':
                base = 16;
                break;

            case 'd':
            case 'i':
                flags |= SIGN;
            case 'u':
                break;

            default:
                if (str <= end)
                    *str = '%';
                ++str;
                if (*fmt) {
                    if (str <= end)
                        *str = *fmt;
                    ++str;
                } else {
                    --fmt;
                }
                continue;
        }
        if (qualifier == 'L')
            num = va_arg(args, long long);
        else if (qualifier == 'l') {
            num = va_arg(args, unsigned long);
            if (flags & SIGN)
                num = (signed long) num;
        } else if (qualifier == 'Z' || qualifier == 'z') {
            num = va_arg(args, size_t);
        } else if (qualifier == 'h') {
            num = (unsigned short) va_arg(args, int);
            if (flags & SIGN)
                num = (signed short) num;
        } else {
            num = va_arg(args, unsigned int);
            if (flags & SIGN)
                num = (signed int) num;
        }
        str = number(str, end, num, base,
                field_width, precision, flags);
    }
    if (str <= end)
        *str = '\0';
    else if (size > 0)
        /* don't write out a null byte if the buf size is zero */
        *end = '\0';
    /* the trailing null byte doesn't count towards the total
    * ++str;
    */
    return str-buf;
}