将lambda转换为std :: function时强制执行const正确性

Question

I have a function that takes in a std::function as a parameter. However, I want to ensure the function being passed in is not allowed to modify the parameters passed to it.

Here's the simple version of the function (note that T can be, and usually is, a reference):

template <class T>
void Bar(std::function<void(std::add_const_t<T>)> func)
{
    // ...
}

Bad usage:

Bar<int&>([](int&) { /* Do nasty stuff! */ }); /* A-OK! */

I want to disallow that usage, but this code compiles perfectly fine, even though I feel like it shouldn't.

Interesting thing is, if I get rid of the template parameter, ie:

void Bar(std::function<void(const int&)> func)
{
    // ...
}

Then, this usage wouldn't compile (as it shouldn't):

Bar([](int&) { /* Do nasty stuff! */ }); /* Error C2664 */

How can I enforce this and still keep the template parameter?

Answer 1

Note that std::add_const_t<int &> is int & , for you are not adding const to int . Instead you are adding const to a reference to int and you obtain a const reference to int (that is int & ), not a reference to a const int .

A simple way to work around it can be:

#include<functional>
#include<type_traits>

template<typename T>
struct to_const_ { using type = std::add_const_t<T>; };

template<typename T>
struct to_const_<T &> { using type = std::add_const_t<T> &; };

template<typename T>
using to_const_t = typename to_const_<T>::type;

template <class T>
void Bar(std::function<void(to_const_t<T>)> func)
{}

int main() {
    Bar<int&>([](int&) {});
}

The code above doesn't compile (as requested), unless you turn it to:

Bar<int&>([](const int &) {});

Note that it works correctly only with lvalue references as it stands, but adding the support for rvalue references and pointers is straightforward if you got the idea.

---

It follows a minimal, (probably) working example:

#include<functional>
#include<type_traits>

template<typename T>
struct to_const_ { using type = std::add_const_t<T>; };

template<typename T>
struct to_const_<T &> { using type = std::add_const_t<T> &; };

template<typename T>
struct to_const_<T &&> { using type = std::add_const_t<T> &&; };

template<typename T>
struct to_const_<T * const> { using type = std::conditional_t<std::is_pointer<T>::value, typename to_const_<T>::type * const, std::add_const_t<typename to_const_<T>::type> * const>; };

template<typename T>
struct to_const_<T *> { using type = std::conditional_t<std::is_pointer<T>::value, typename to_const_<T>::type *, std::add_const_t<typename to_const_<T>::type> *>; };

template<typename T>
using to_const_t = typename to_const_<T>::type;

template <class T>
void Bar(std::function<void(to_const_t<T>)> func)
{}

int main() {
    Bar<int **>([](const int **) {});
}

Answer 2

You can use static_assert to make compilation fail, with help from templates.

//Base case - T is non-const, possibly pointer or reference
template <typename T> struct is_const_param { static constexpr bool value = !std::is_lvalue_reference<T>::value && !std::is_rvalue_reference<T>::value && !std::is_pointer<T>::value; };

//T is const, but possibly pointer to non-const
template <typename T> struct is_const_param<const T> { static constexpr bool value = !std::is_pointer<T>::value; };

//Remove reference, try again
template <typename T> struct is_const_param<const T&> : is_const_param<const T> {  };

//Remove reference, try again
template <typename T> struct is_const_param<const T&&> : is_const_param<const T> {  };

//Remove pointer, try again
template <typename T> struct is_const_param<const T*> : is_const_param<const T> { };

//Remove pointer, try again
template <typename T> struct is_const_param<const T* const> : is_const_param<const T> { };

The static_assert would just look like:

template <class T>
void Bar(std::function<void(T)>)
{
    static_assert(is_const_param<T>::value, "...");
}

This is set up to only succeed when T is:

1. Passed by value (see below).
2. Passed by constant reference.
3. Passed by pointer(s) to constant.

You can see some test cases here if you want to see examples of what makes it succeed or fail.

---

This was set up to allow passing by value normally, like Bar<int> . If you want to change it to only allow Bar<const int> , remove the is_const_param<const T*> specialization and change the initialization of value in the unspecialized template to false . You can see that here .