C++ compile code depending on the concrete type of auto

Question

I have a C++ piece of code

auto returnvalue = m_func(x, y, z);

where the type of m_func depends on a template parameter. Afterwards I deal with the returnvalue which works fine until m_func is a function returning void. But I need a mechanism which calls

m_func(x,y,z)

if the return value of m_func is void and the above version is not. Overall in pseudo code it need to look like

if ( returnvalue of m_func is void ) 
     call m_func directly
else 
     auto retval = m_func(...) 
     handle the return value

How can these be done with C++11/14?

Edit:

m_func is either:

void func(type1 arg1, type2 arg, ...)

or

std::tuple<...> func(type1 arg1, type2 arg, ...)

What is the template type of `m_func` based off? The arguments? — OrdoFlammae, Sep 30 '19 at 15:37
It really depends. Can you show us how you are calling `my_func` (what context it is in)? — NathanOliver, Sep 30 '19 at 15:39
@sweenish it does matter (probably). The solution may be different depending on it. — eerorika, Sep 30 '19 at 15:43
Related: https://stackoverflow.com/questions/42725427/handling-a-void-variable-in-a-templatized-function-in-c11, https://stackoverflow.com/questions/56256640/function-argument-returning-void-or-non-void-type — Quentin, Sep 30 '19 at 15:45
Doubt it. This is a SFINAE problem based on the return type of m_func, where we only care if it is void or not. What I'd rather see is m_func itself. — sweenish, Sep 30 '19 at 15:46

eerorika · Answer 1 · 2019-09-30T16:16:21.113

Prior to C++17, you can use template specialisation:

template<class R>
struct handle {
    template<class F>
    static void the_return_value(F m_func) {
        auto retval = m_func(x, y, z);
        // handle the return value
    }
};

template<>
struct handle<void> {
    template<class F>
    static void the_return_value(F m_func) {
        m_func(x, y, z);
    }
};

// usage
using R = decltype(m_func(x, y, z));
handle<R>::the_return_value(m_func);

In C++17, you can use if constexpr instead:

using R = decltype(m_func(x, y, z));
if constexpr (std::is_void_v<R>) {
    m_func(x, y, z);
} else {
    auto retval = m_func(x, y, z);
    // handle the return value
}

Jarod42 · Accepted Answer · 2019-10-01T08:02:48.850

4

Whereas C++17 has if constexpr to handle it simply, C++11/C++14 has to use some overload to handle it via SFINAE or tag dispatching or specialization, follow up a tag dispatching version:

void internal_impl(std::true_type/*, ... */) {
    m_func(x, y, z);
}
void internal_impl(std::false_type/*, ... */) {
    auto value = m_func(x, y, z);

    foo(value);
}

void internal(/*... */) {
    internal_impl(std::integral_constant<bool,
                                         std::is_void<decltype(m_func(x, y, z))>::value>{}
                  /*, ...*/);
}

edited Oct 01 '19 at 08:02

answered Sep 30 '19 at 16:13

Jarod42

203,559
14
181
302

I had to add a `{} ` to `std::integral_constant::value>` and then it works like a charm and it is still readable by our non C++ programmers. – M.K. aka Grisu Oct 01 '19 at 07:28
1

missing `{}` added. – Jarod42 Oct 01 '19 at 08:03

C++ compile code depending on the concrete type of auto

2 Answers2