返回 void 的模板函数

template function returning void

本文关键字：函数 void 返回      更新时间：2023-10-16

我的日志记录类中有以下函数：

template<class T> 
inline T ErrLog(T ret, const char* Format, ...)
{
    va_list args; va_start( args, Format ); _vsnprintf(mypWorkBuffer, MaxLogLength, Format, args); va_end(args);
    // do some fancy logging with mypWorkBuffer
    return ret;
}

(mypWorkBuffer 在别处定义(

这对我来说是一个非常方便的快捷方式，因为我可以记录错误并在一行中退出，通过消除错误处理使代码更具可读性：

int f(x) {
   if (x<0) return ErrLog(-1, "f error, %d too small", x);
   ...
}

(而不是 

int f(x) {
   if (x<0) {
      Log("f error, %d too small", x);
      return -1;
   }
   ...
}

(

我遇到的问题是 f 是否返回 void。我想做

void f(x) {
   if (x<0) return ErrLog(void, "f error, %d too small", x);
   ...
}

但这不能编译。

我想到了专业化，那就是添加：

inline void ErrLog(const char* Format, ...)
{
    va_list args; va_start( args, Format ); _vsnprintf(mypWorkBuffer, MaxLogLength, Format, args); va_end(args);
    // do some fancy logging with mypWorkBuffer
    return;
}

这允许我做 

return ErrLog("f error, %d too small", x);

但是我不确定返回 char* 的函数是否安全。例如，考虑：

char* f(x) {
   if (x<0) return ErrLog("error", "f error , %d too small", x);
   ...
}

我认为这个将同时匹配模板和专业化。

任何想法/更好的解决方案？

我认为只使用逗号运算符更惯用，也简单得多：

inline void Errlog(const char *format,...) { /* ... */ }
void f(int x) {
    if (x<0) return Errlog("f error...");
}
double g(double x) {
    if (x<0) return Errlog("x is negative..."),-1.0;
    else return sqrt(x);
}

逗号运算符的左手大小可以是void表达式。

这完全不需要使用模板化函数。

编辑：如果你真的不喜欢使用逗号...

如果您真的想使用功能接口，您有三个选项。给定一个泛型函数(我在这里使用 std::forward，以便我们可以将其与引用等一起使用(：

template <class T>
inline T &&ErrLog(T &&ret,const char *format,...) {
    /* logging ... */
    return std::forward<T>(ret);
}

您可以：

1( 对无效情况使用单独的功能。

void ErrLogV(const char *format,...) {
    /* logging ... */
}
void foo1(int x) {
    if (x<0) return ErrLogV("foo1 error");
}

2(使用特殊的"标签"类型过载：

static struct errlog_void_t {} errlog_void;
inline void ErrLog(errlog_void_t,const char *format,...) {
    /* logging ... */
}
void foo2(int x) {
    if (x<0) return ErrLog(errlog_void,"foo2 error");
}

3(或者使用抛弃参数并投射为void：

void foo3(int x) {
    // uses generic ErrLog():
    if (x<0) return (void)ErrLog(0,"foo3 error");
}

第二次编辑：为什么没有 ret 参数的版本无法正常工作

你可以用ret安全地定义版本;它不是模棱两可的，但不一定会在你想要的时候使用。根本问题是，在一个上下文中，您将需要一种行为，而在另一种上下文中，您将需要另一种行为，但函数调用参数将具有完全相同的类型。

请考虑以下示例：

#include <cstdarg>
#include <cstdio>
#include <utility>
using namespace std;
template <typename T>
T &&foo(T &&x,const char *format,...) {
    puts("T-version");
    va_list va;
    va_start(va,format);
    vprintf(format,va);
    va_end(va);
    puts("");
    return forward<T>(x);
}
void foo(const char *format,...) {
    puts("void-version");
    va_list va;
    va_start(va,format);
    vprintf(format,va);
    va_end(va);
    puts("");
}
int main() {
    foo("I want the void overload: %s, %s","some string","some other string");
    foo("I want to return this string","I want the const char * overload: %s","some string");
}

这将编译！但只会调用foo的第一个版本。编译器无法将您的意图与参数类型区分开来。

为什么不模棱两可？

foo的两个版本都将是重载解决的候选者，但第一个版本将是更好的匹配。你可以参考过程的详细描述(尤其是关于排名的部分(，但总之，当你有两个或两个以上的const char *参数时，第一个版本的foo的const char *第二个参数比第二个版本的省略号参数更具体。

如果您只有一个const char *参数，那么 void 返回版本将胜过泛型版本，因为非模板重载优先于模板重载，其他条件相同：

foo("this will use the void-version");

简而言之，使用重载将编译，但会给出令人惊讶且难以调试的行为，并且无法处理您的void返回版本需要多个参数的情况。

对于void问题，请使用返回 0 int 专用化，然后忽略它：

void f(x) {
   if (x<0) {
      ErrLog(0, "f error, %d too small", x);
      return;
   }
   ...
}

对于返回char *的函数，只要返回的值是静态的，您就可以使其安全(但是当您使用C++时，您可以使用std::string

(： 
char* f(x) {
   static char err[] = "error";
   if (x<0) return ErrLog(err, "f error , %d too small", x);
   ...
}

编辑：

对于void部分，我无法想象您如何避免块(独立于模板问题(：

void g(int x);
void f(int x) {
    if (x<0) return g(x); // 2 errors here : g returns void and f returns void
}

如果函数g返回 void，则不能将其用作 return 语句的值，无论此函数是什么。无论如何，您不能在返回void的函数中使用return something;。我能想象的最好的(但这不是你问的(是：

void f(x) {
   if (x<0) ErrLog(0, "f error, %d too small", x);
   else {
      ...
   }
}

为 ELSE 部分创建另一个块...

我建议您使用用户定义的 Void 类型的模板专用化来处理您的 Void 案例。抱歉，这是 C++14，但您应该能够非常轻松地转换它，只需相应地更改返回类型

template<class T>
auto ErrLog(T ret, const char* Format, ...)
{
    return ret;
}
struct Void{ };
template<>
auto ErrLog(Void ret, const char* Format, ...)
{
    return;
}
int main()
{
    ErrLog(Void{}, "f error, %d too small");
    ErrLog(-1, "f error, %d too small");
}

我也没有传递可变参数模板 Args，这个解决方案更多的是向您展示这个想法。

相关文章：