从自定义 printf 函数返回一个 const char*

Question

我编写了一个自定义打印函数。我的问题是我需要返回一个const char*，因为它必须在另一个函数中使用。我根本不知道如何管理...

anotherFunction (const char* text /*Here*/, unsigned __int32 value, unsigned __int64 bigVal);

我知道以下示例无法正常工作。这就是我到目前为止所尝试的。

const char* CatchMessage (const char *message, ...)
{
    va_list  args;
    va_start (args, message);
    /*?*/
    va_end   (args);
    return message;
}

我还只是设法在 cmd 中获得正确的输出，但我实际上需要它作为返回值。

void CatchMessage (const char *message, ...)
{
    va_list  args;
    va_start (args, message);
    vfprintf (stdout, message, args);
    va_end   (args);
}

呼叫：

CatchMessage ("Some Input %s and %d equals to %d", randString, randNumber, secRandNumber);

应该返回：

"Some Input stuff and 12 equals to 6"

我无法找到解决方案。任何帮助将不胜感激。

问：如何让这个CatchMessage 函数返回格式正确的const char*？

Answer 1

听起来CatchMessage 应该将指针指向一个字符缓冲区（及其大小），然后将vsnprintf() 指向该缓冲区。

Answer 2

既然您使用的是 C++（至少根据问题上的标签），为什么不直接返回 std::string 中的字符串？

Answer 3

返回 (const) char * 的问题是你必须在某处有一个缓冲区。

有几种方法可以做到这一点：

1. 调用者必须提供该缓冲区
2. 你必须malloc()它
3. 函数本身作为static 缓冲区，但这会使其不可重入 - 这对多线程等不利。

广告 1：

void CatchMessage(char * result, size_t maxlen, const char *message, ...)
{
    va_list ap;
    va_start(ap, message);
    vsnprintf(result, maxlen, message, ap);
    va_end(ap);
}

调用

char buffer[500];
CatchMessage(buffer, sizeof buffer, "Some Input %s and %d equals to %d", randString, randNumber, secRandNumber);
anotherfunction(buffer, ...)

广告 2：

char * CatchMessage(const char *message, ...)
{
    size_t size = 500;
    char * result = malloc(size);
    if (!result) return NULL; // error handling!
    while (1) {
        va_list ap;
        va_start(ap, message);
        size_t used = vsnprintf(result, size, message, ap);
        va_end(ap);
        char * newptr = realloc(result, size);
        if (!newptr) { // error
            free(result);
            return NULL;
        }
        result = newptr;
        if (used <= size) break;
        size = used;
    }
    return result;
}

调用

char * buffer = CatchMessage(buffer, sizeof buffer, "Some Input %s and %d equals to %d", randString, randNumber, secRandNumber);
if (!buffer) { /* error handling: no memory! */ }
anotherfunction(buffer, ...)
free(buffer); // important for avoiding memory leaks

广告 3：

char * CatchMessage(const char *message, ...)
{

    static char result[500]; // static is important here! Otherwise the memory will be freed immediately after returning.
    va_list ap;
    va_start(ap, message);
    vsnprintf(result, sizeof result, message, ap);
    va_end(ap);
    return result;
}

调用

char * buffer = CatchMessage(buffer, sizeof buffer, "Some Input %s and %d equals to %d", randString, randNumber, secRandNumber);
anotherfunction(buffer, ...)

没有其他选择，尤其是不定义

char result[500];

在函数中然后返回它：这个数组存在于堆栈中，返回后立即释放。调用者不能安全地访问它；它的内容只是未定义。

Answer 4

如果你不关心重入，你可以返回指向静态缓冲区的指针：

#define MESSAGE_MAX 1024

const char *
CatchMessage (const char *message, ...)
{
    static buffer[MESSAGE_MAX];
    va_list  args;
    va_start (args, message);
    vsnprintf (buffer, MESSAGE_MAX, message, args);
    va_end   (args);
    return buffer;
}

注意事项：

1. 此实现不是线程安全的。如果您关心线程安全，请使用线程本地存储而不是静态缓冲区

2. 此实现对消息长度有硬编码上限。如果这是不可取的，并且您的编译器符合 C99，您可以首先调用 vsprintf 并使用 NULL 作为第一个参数来了解结果字符串的长度，然后分配该侧的缓冲区。

Answer 5

在 C++ 中，使用可变参数是不好的，因为它特别强调类型安全（和内存安全）。因此，您可能想提出一个实际上是类型安全的版本（是的，这是可能的），但又提出了一个类似的接口：

template <typename H, typename... Args>
void format(std::ostream& out,
            char const* format,
            size_t len,
            H const& head,
            Args const&... args);

// Variations with 'char const (&)[N]' and 'std::string' formats
// as well as variations returning directly a 'std::string'.

现在，format 的实现已经不是太难了；特别是在不支持位置参数的情况下。一个简单的可以在下面找到：

inline void format_string(std::ostream& out, char const* const* c) { out << *c; }
inline void format_string(std::ostream& out, std::string const* s) { out << *s; }
inline void format_string(std::ostream& out, void const*); // will throw

template <typename Integral, typename = enable_integral<Integral>::type>
inline void format_integral(std::ostream& out, Integral const* i) { out << *i; }
inline void format_integral(std::ostream& out, void const*); // will throw

inline size_t format_consume(std::ostream& out,
                             char const* const format,
                             size_t const length)
{
    char const* end = format + length;
    char const* current = format;

    do {
        // 1. Find first "format identifier", output stuff in-between
        char const* perc = std::find(current, end, '%');

        if (perc != current) { out.write(current, perc - current); }

        current = perc;

        // 2. %% is % escaped by %, so output it directly
        while (*current == '%' and *(current + 1) == '%') {
            out.put('%');
            current += 2;
        }
    } while (current != end and *current != '%');

    // 3. Return number of characters of format parameter consumed
    return current - format;
} // format_consume

inline void format(std::ostream& out, char const* format, size_t len) {
     size_t const consumed = format_consume(out, format, len);

     if (consumed != len) { throw std::runtime_exception("Missing arguments"); }
} // format

template <typename H, typename typename... Args>
void format(std::ostream& out,
            char const* format,
            size_t len,
            H const& head,
            Args const&... args)
{
     size_t const consumed = format_consume(out, format, len);

     if (consumed == len) { throw std::runtime_exception("Extraneous arguments"); }

     format += consumed;
     len -= consumed;

     assert(*format == '%');

     switch(*(format+1)) {
     case 's': format_string(out, &head); break;
     case 'd': format_integral(out, &head); break;
     default: throw std::runtime_exception("Invalid specifier");
     }

     format(out, format+2, len-2, args...);
} // format

在一般情况下，它稍微有点麻烦，因为您需要解析修饰符等...但是，对于生产就绪的实现，我建议查看 Boost.Format。

Answer 6

char* CatchMessage (size_t size, const char *message, ...)
{
    char result[size];
    va_list  args;
    va_start (args, message);
    vsprintf (result, message, args);
    va_end   (args);
    return result;
}

参考this。

对于glglgl：如果你想使用干净的方式，请使用vsnprintf(result, size, message, args)