Question

我实现了一个Visit函数（在变体上），该函数检查变体中当前活动的类型是否与函数签名（更确切地说是第一个参数）匹配。基于这个不错的answer。例如

#include <variant>
#include <string>
#include <iostream>

template<typename Ret, typename Arg, typename... Rest>
Arg first_argument_helper(Ret(*) (Arg, Rest...));

template<typename Ret, typename F, typename Arg, typename... Rest>
Arg first_argument_helper(Ret(F::*) (Arg, Rest...));

template<typename Ret, typename F, typename Arg, typename... Rest>
Arg first_argument_helper(Ret(F::*) (Arg, Rest...) const);

template <typename F>
decltype(first_argument_helper(&F::operator())) first_argument_helper(F);

template <typename T>
using first_argument = decltype(first_argument_helper(std::declval<T>()));

std::variant<int, std::string> data="abc";
template <typename V>
void Visit(V v){
using Arg1 = typename std::remove_const_t<std::remove_reference_t<first_argument<V>>>;//... TMP magic to get 1st argument of visitor + remove cvr, see Q 43526647
if (! std::holds_alternative<Arg1>(data)) {
std::cerr<< "alternative mismatch\n";
return;
}
v(std::get<Arg1>(data));
}
int main(){
    Visit([](const int& i){std::cout << i << "\n"; });
    Visit([](const std::string& s){std::cout << s << "\n"; });
    // Visit([](auto& x){}); ugly kabooom
}

这可行，但当用户传递通用（例如[](auto&){}）lambda时，会因用户不友好的编译时错误而爆炸。有没有一种方法可以检测到这一点，并对此给出很好的static_assert()？如果它还可以与函数模板一起使用，而不仅仅是与lambda一起使用，那也将很好。

请注意，我不知道lambda可能做什么，所以我无法对Dummy类型做一些聪明的事情，因为lambda可能会调用类型上的任意函数。换句话说，我无法尝试在std::void_t和int的2个std::string测试中调用lambda，并且如果可行，则假定它是通用的，因为他们可能会尝试在.BlaLol()上调用int和string。

Answer 1

有没有一种方法可以检测到这种情况并提供有关它的static_assert？

我想您可以在operator()类型上使用SFINAE。

跟随一个例子

#include <type_traits>

template <typename T>
constexpr auto foo (T const &)
   -> decltype( &T::operator(), bool{} )
 { return true; }

constexpr bool foo (...)
 { return false; }

int main()
 {
   auto l1 = [](int){ return 0; };
   auto l2 = [](auto){ return 0; };

   static_assert( foo(l1), "!" );
   static_assert( ! foo(l2), "!" );
 }

如果您想通过{{来使用它，则可以代替bool，而返回std::true_type（从foo()开始）或std::false_type（从第二版本）。 1}}。

如果它还可以与函数模板一起使用，而不仅仅是与lambda一起使用，那也很好。

我认为不可能以如此简单的方式实现：lambda（也是通用lambda）是一个对象；模板函数不是对象，而是一组对象。您可以将一个对象传递给一个函数，而不是一组对象。

但是上述解决方案也应适用于具有decltype()的类/结构：当存在单个非模板operator()时，应从{{1}获得operator() };否则（没有1，多个foo()，模板operator()），operator()应该返回operator()。

Answer 2

还有另一个更简单的选择：

#include <type_traits>
...
template <typename V>
void Visit(V v) {
   class Auto {};
   static_assert(!std::is_invocable<V, Auto&>::value);
   static_assert(!std::is_invocable<V, Auto*>::value);
   ...
}

Auto类只是在V参数中不可能出现的发明类型。如果V接受Auto作为参数，则它必须是通用的。

我在coliru中进行了测试，可以确认解决方案涵盖了以下情况：

Visit([](auto x){}); // nice static assert
Visit([](auto *x){}); // nice static assert
Visit([](auto &x){}); // nice static assert
Visit([](auto &&x){}); // nice static assert

我不确定这是否涵盖了您可能不知道的所有可能的lambda ：)

Answer 3

#include <variant>
#include <string>
#include <iostream>

template <class U, typename T = void>
struct can_be_checked : public std::false_type {};

template <typename U>
struct can_be_checked<U, std::enable_if_t< std::is_function<U>::value > >  :  public std::true_type{};

template <typename U>
struct can_be_checked<U, std::void_t<decltype(&U::operator())>> :  public std::true_type{};


template<typename Ret, typename Arg, typename... Rest>
Arg first_argument_helper(Ret(*) (Arg, Rest...));

template<typename Ret, typename F, typename Arg, typename... Rest>
Arg first_argument_helper(Ret(F::*) (Arg, Rest...));

template<typename Ret, typename F, typename Arg, typename... Rest>
Arg first_argument_helper(Ret(F::*) (Arg, Rest...) const);

template <typename F>
decltype(first_argument_helper(&F::operator())) first_argument_helper(F);

template <typename T>
using first_argument = decltype(first_argument_helper(std::declval<T>()));

std::variant<int, std::string> data="abc";


template <typename V>
void Visit(V v){
    if constexpr ( can_be_checked<std::remove_pointer_t<decltype(v)>>::value )
    {
        using Arg1 = typename std::remove_const_t<std::remove_reference_t<first_argument<V>>>;//... TMP magic to get 1st argument of visitor + remove cvr, see Q 43526647
        if (! std::holds_alternative<Arg1>(data)) 
        {
            std::cerr<< "alternative mismatch\n";
            return;
        }
        v(std::get<Arg1>(data));
    }
    else
    {
        std::cout << "it's a template / auto lambda " << std::endl;
    }


}

template <class T>
void foo(const T& t)
{
    std::cout <<t << " foo \n";
}

void fooi(const int& t)
{
    std::cout <<t << " fooi " << std::endl;
}

int main(){
    Visit([](const int& i){std::cout << i << std::endl; });
    Visit([](const std::string& s){std::cout << s << std::endl; });
    Visit([](auto& x){std::cout <<x << std::endl;}); // it's a template / auto lambda*/
    Visit(foo<int>);

    Visit<decltype(fooi)>(fooi);
    Visit(fooi);                 


    // Visit(foo); // => fail ugly
}

我不知道是否要这样做，但是可以通过static_assert使用自动lambda作为参数传递。

我认为无法对模板功能执行相同操作，但不确定。

是否可以static_assert确定lambda不是通用的？

3 个答案: