template function returning void

Question

I have the following function in my logging class:

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 is defined elsewhere)

This is a very handy shortcut to me cause I can log an error and exit in one line which makes the code more readable by getting error handling out of the way:

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

(instead of

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

)

The problem I have is if f returns void. I would like to do

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

But this does not compile.

I thought about specialization, that is adding:

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;
}

This allows me to do

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

However I'm not sure it's safe for functions returning char*. For example consider:

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

I think this one will match both template and specialization.

Any thoughts/better solutions ?

Why does ret even get passed through ErrLog? If it's not used or modified it doesn't really have any business being there. Doubly so when it's the only reason for this being a template. — etheranger
– etheranger, Commented Feb 19, 2015 at 6:18
etheranger - ret is being returned, that's the whole point n.m. there is no try catch throw here, not sure what you refer to — kofifus
– kofifus, Commented Feb 19, 2015 at 8:18
"there is no try catch throw here". That's exactly the problem. — n. m. could be an AI
– n. m. could be an AI, Commented Feb 19, 2015 at 8:53

halfflat · Accepted Answer · 2015-02-19 11:00:20Z

6

I think it is more idiomatic and much, much simpler to just use the comma operator:

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);
}

The left hand size of the comma operator can be a void expression.

This obviates the need to use a templated function at all.

Edit: if you really don't like using comma...

You have three options if you really want to use a function interface. Given a generic function (I'm using std::forward here, so that we can use it with references and so on):

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

You can either:

1) Use a separate function for the void case.

void ErrLogV(const char *format,...) {
    /* logging ... */
}

void foo1(int x) {
    if (x<0) return ErrLogV("foo1 error");
}

2) Overload with a special 'tag' type:

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) Or use a throw away argument and cast to void:

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

Second edit: why the version without the ret parameter can't work

You can safely define the version with ret; it's not ambiguous, but it won't necessarily be used when you want it to be. The fundamental problem is that in one context you will want one behaviour, and in another the other behaviour, but the function call parameters will have the exact same type.

Consider the following example:

#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");
}

This will compile! But only the first version of foo will be called. The compiler cannot distinguish your intent from the argument types.

Why is it not ambiguous?

Both versions of foo will be candidates for overload resolution, but the first one will be a better match. You can refer to a detailed description of the process (especially the section on ranking), but in short, when you have two or more const char * arguments, the const char * second parameter of the first version of foo is more specific than the ellipsis parameter of the second version.

If you have only one const char * argument, then the void-returning version will win over the generic one, because non-template overloads are prefered to template-overloads, other things being equal:

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

In short, using the overload will compile, but will give surprising and hard to debug behaviour, and can't handle the case where your void-returning version takes more than one argument.

edited Feb 19, 2015 at 11:00

answered Feb 19, 2015 at 7:17

halfflat

1,5948 silver badges11 bronze badges

Sign up to request clarification or add additional context in comments.

8 Comments

Pradhan Over a year ago

I don't see the point of what OP is trying to achieve, but the comma operator? Why wouldn't you just put it in a block?

halfflat Over a year ago

I believe the OP is trying to have a way of logging these sorts of error-return situations which minimally clutters the code. For example, a block can't be used in the middle of another expression, and with most coding style conventions, would replace one line with two to four.

kofifus Over a year ago

yes exactly, my code is meant to give a one liner log and return, to avoid cluttering the code with error handling blocks Interesting use of the comma ! but this is highly unusual and IMO confusing so looking for something better

halfflat Over a year ago

Comma is great; everyone should know how it works so they don't get surprised :) Nonetheless, amended answer with what I think are your three alternatives, keeping a function-only interface.

rici Over a year ago

@halfflat: The other alternative to comma is to make ErrLog always return true and write if (error_condition && ErrLog(fmt, ...)) return return_value;

|

Serge Ballesta · Accepted Answer · 2015-02-19 08:44:51Z

0

For the void question, use an int specialization returning 0 and later ignore it :

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

For functions returning char * you can make it safe provided the returned value is static (but as you are using C++ you could alse use std::string) :

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

EDIT :

For the void part, I cannot imagine how you can avoid a block (independantly of the templating question) :

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

If a function g returns void, you cannot use it as the value of a return statement, whatever this function is. And anyway you cannot use a return something; in a function returning void. The best I can imagine (but it is not what you asked) is :

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

creating another block for the else part ...

edited Feb 19, 2015 at 8:44

answered Feb 19, 2015 at 7:02

Serge Ballesta

150k13 gold badges137 silver badges267 bronze badges

3 Comments

kofifus Over a year ago

the whole point is to avoid a block and a separate return so I can just have a one line if (x<0) return ErrLog( ...

Serge Ballesta Over a year ago

@kofifus : I can understand your wish, but the compiler won't allow you to use return x; in a void returning function ... I've edited my post

kofifus Over a year ago

a function returning void can def return another function returning void, so your f functions compiles fine (at least in VS2013)

dau_sama · Accepted Answer · 2015-02-19 09:18:27Z

0

I suggest you to use template specialization with a user defined Void type, for handling your Void case. Sorry this is C++14, but you should be able to convert it really easily, just change the return types accordingly

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");
}

Also I didn't pass the variadic template Args, this solution is more to show you this idea.

answered Feb 19, 2015 at 9:18

dau_sama

4,3772 gold badges26 silver badges32 bronze badges

1 Comment

dau_sama Over a year ago

indeed, just a bit more concise and without a comma operator overload :-)

Collectives™ on Stack Overflow

template function returning void

3 Answers 3

8 Comments

3 Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

8 Comments

3 Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related