How to write function with the matching const modifier on argument and return types?

user_153133 0
Viewed 168

I want to write a function that extracts a pointer field from a struct. The requirement is that if I pass the struct as a const argument, the returned type should be const. If not, the returned type should not be const.

For instance,

struct S {
    char *p;
};

// approach 1: two overload functions with duplicate body
auto extract(S &input) -> int * {
    return reinterpret_cast<int *>(input.p + 12);
}
auto extract(const S &input) -> const int * {
    return reinterpret_cast<const int *>(input.p + 12);
}

// approach 2: macro
#define macro_extract(input) (reinterpret_cast<int *>(input.p + 12))

Is there any trick in template or latest C++ standard that can write a strongly typed function without duplicating the body?

EDIT: Changed the example a bit to reflect more accurately of the real problem.

templates c++ types
4 Answers

Here's a solution with a single function template:

template<typename T, 
         typename = std::enable_if_t<
                      std::is_same_v<
                        std::remove_cv_t<
                          std::remove_reference_t<T>>, S>>>
auto extract(T&& input) 
  -> std::conditional_t<
       std::is_const_v<
         std::remove_reference_t<T>>, int const *, int *> 
{
    return input.p;
}

Here's a demo.

I think it goes without saying that you'd be better off with an overload set. If the function body is large, you can still call the non-const version from the const overload, and add the const there.

user_83728530

if constexpr and auto as return type solution:

#include <type_traits>

struct S {
    int *p;
};

template<typename T>
auto extract(T &&input) {
    static_assert(std::is_same_v<std::decay_t<decltype(input)>,S>, , "Only struct S is supported");
    if constexpr(!std::is_const_v<std::remove_reference_t<decltype(input)>>) {
        return input.p;
    } else {
        return const_cast<const int*>(input.p);
    }
}

int main () {

    S i;
    using t = decltype(extract(i));
    static_assert(std::is_same_v<t,int*>);

    S const i_c{0};
    using t_c = decltype(extract(i_c));
    static_assert(std::is_same_v<t_c,const int*>);

    return 0;
}
user_131614510
user_63856400

SFINAE should be able to do this. The approximate format is:

template<class T, 
    class allow=std::enable_if_t<std::is_base_of_v<S, T>>>
auto extract(T&& input) -> decltype(input.p) {
    return input.p;
}

Basically using universal forwarding references to make it work for anything: S, S&, const S&, S&&, volatile S&, etc.

user_8450920
Related