尝试使用具有尾随返回类型的lambda的SFINAE时出现硬错误
在使用具有尾随返回类型的lambda的SFINAE时出现硬错误是由于编译器无法正确推导lambda函数的返回类型导致的。SFINAE（Substitution Failure Is Not An Error）是一种编译时的技术，用于在模板编程中根据类型的可用性进行条件编译。
具有尾随返回类型的lambda函数是C++11引入的一种语法，它允许我们在lambda函数内部使用auto关键字来推导返回类型。然而，由于SFINAE的机制是基于函数模板的，而lambda函数并不是一个真正的函数模板，因此在使用SFINAE时会出现编译错误。
解决这个问题的方法是使用decltype关键字来显式指定lambda函数的返回类型，而不是依赖于自动推导。例如：
template<typename T>
auto foo(T t) -> decltype(t()) {
return t();
}
int main() {
auto lambda = []() { return 42; };
int result = foo(lambda);
return 0;
}在上面的示例中，我们使用decltype(t())来指定lambda函数的返回类型，以避免SFINAE错误。这样，编译器就能正确推导lambda函数的返回类型，并且代码可以顺利编译通过。
对于这个问题，腾讯云提供了一系列的云计算产品和服务，可以帮助开发者构建和管理云端应用。具体推荐的产品和服务取决于具体的应用场景和需求。您可以参考腾讯云的官方文档和产品介绍页面，了解更多关于云计算的知识和腾讯云的相关产品。
腾讯云产品介绍链接：https://cloud.tencent.com/product
相关·内容
在尝试编译时，令人惊讶的是，它给出了一个错误，因为lambda函数的auto参数已被解析为std::string，并且编译器在调用test时不知道如何将std::string转换为int或Widget。
但是，我想知道为什么编译器选择第二个invok函数而不是第一个函数，而第一个函数会成功：
#include <string>
#include <functional>
struct Widget {};
bool test(int );
bool test(Widget );
void invok(std::function<bool(int)> )
浏览 18提问于2017-09-11得票数 2
跳过表达式的返回类型时
C++11中的下列代码
auto function(X x, Y y) -> decltype(x + y)
{
return x + y;
}
等于C++14中的下列代码
decltype(auto) function(X x, Y y)
{
return x + y;
}
但是，在C++14中，可以不使用C++14规则推断返回类型。
auto function()
{
return 0;
}
当我知道返回类型是什么的时候
C++11中的下列代码
auto function() -> int
{
return 0;
}
等于
浏览 4提问于2014-08-16得票数 12
回答已采纳
我有一个类似容器的类，它的方法类似于std::apply。我想用const限定符重载这个方法，但是当我试图用泛型lambda调用这个方法时，我会从std::invoke_result_t的实例化中得到一个严重的错误。我使用std::invoke_result_t推断方法的返回值，并对参数执行SFINAE检查。
#include <type_traits>
#include <utility>
template <typename T>
class Container
{
public:
template <typename F>
浏览 0提问于2018-11-16得票数 4
回答已采纳
2回答
考虑以下代码：
// -------------------------------------------------------------------------- //
// Preprocessor
#include <array>
#include <vector>
#include <utility>
#include <iostream>
#include <type_traits>
// -----------------------------------------------------------------
浏览 1提问于2017-03-26得票数 2
回答已采纳
1回答
由于decltype作为一种返回类型，C++11非常容易地引入装饰器。例如，考虑这个类：
struct base
{
void fun(unsigned) {}
};
我想用额外的特性来装饰它，因为我将用不同的装饰多次这样做，所以我首先介绍了一个decorator类，它简单地将所有东西转发给base。在真正的代码中，这是通过std::shared_ptr完成的，这样我就可以删除装饰并恢复“裸”对象，一切都是模板化的。
#include <utility> // std::forward
struct decorator
{
base b;
template <t
浏览 1提问于2014-11-03得票数 24
回答已采纳
2回答
有关于尾随返回类型、返回类型演绎和非常有用的decltype(auto)的、问题和答案。但是，我没有找到一个答案，因为我们有，所以在中是否需要尾部返回类型。是否有尾随返回类型解决的情况，其中decltype(auto)要么不能使用，要么不能工作(给出意外/不正确的结果)和--首先需要尾随返回类型？
浏览 3提问于2019-09-19得票数 3
回答已采纳
2回答
可能重复：
我希望重载一个函数，这样它就可以自然地用各种不同的lambda(通常有更多或更少的参数)来调用。很明显，我试过的是：
#include <functional>
#include <iostream>
extern void fn(std::function<void(int)>);
extern void fn(std::function<void(int, int)>);
void test()
{
fn([](int a) { std::cout << "lambda with 1 a
浏览 0提问于2012-08-18得票数 11
1回答
我不明白为什么下面的代码不能工作。编译器(gcc)似乎实例化了这两个方法，显然整数要么是有符号的，要么是无符号的，所以总是失败。我以为enable_if在这里就是为了避免这种情况。
问:为什么会出现编译错误，如何避免？
using namespace boost; // or std as you want
template<typename T>
struct test {
// if signed
template< typename enable_if
< is_signed<T>
浏览 0提问于2014-12-08得票数 4
2回答
完美函数别名
、、、、
多年来，我一直在等待C++中的函数别名。他们还是不在这里。我一直在使用宏来生成包装函数。这是我对完美函数别名的最好尝试：
#define FUN_ALIAS(NEW_NAME, ...) \
template <typename... Args> \
inline decltype(auto) NEW_NAME(Args &&... args)
浏览 0提问于2018-08-30得票数 8
回答已采纳
我有一个结构，它有一个名为call的方法，它有一个const重载。唯一的一个参数是std::function，它要么接受int引用，要么接受const引用，这取决于重载。
genericCall方法执行完全相同的操作，但使用模板参数而不是std::function作为类型。
struct SomeStruct {
int someMember = 666;
void call(std::function<void(int&)> f) & {
f(someMember);
std::cout << "
浏览 8提问于2022-04-08得票数 8
回答已采纳
我找到了一篇关于这个主题的很棒的文章，在第10页，作者注意到了两件重要的事情：
当使用启用器重载函数模板时，使能器被放置在声明部分中。
不需要实现通常的dispatcher --一个分配给实现的单独接口函数。
点1可以在SO上找到这个。作者声明(打印出来的文章的第10页)，也可以使用使能器作为函数参数，这就是我要做的事情，但是在那个示例中，ADL失败了。
第2点是依赖于SFINAE和减少函数模板集。当使能器失败时，SFINAE将不会报告错误，并且当选择最适合的模板时，将导致参数的推导。
话虽如此，我还是修改了以前的：
#include <type_traits>
#
浏览 1提问于2014-03-26得票数 0
回答已采纳
我想用标准代码来编写像std::is_union这样的实用程序，我们知道类类型不能扩展联合类型，它是错误的，所以有些代码是这样的
#include <iostream>
template<typename T>
class class_type_can_extends :public T{
public:
using type = void;
};
template<typename T,typename U = void>
struct is_not_union:std::false_type {
};
template<typenam
浏览 1提问于2019-10-15得票数 1
回答已采纳
让我们考虑一下：
void goo () {
std::cout << "void goo ()\n";
}
int goo (int) {
std::cout << "int goo (int)\n";
return 42;
}
现在我想使用如下定义的包装器函数来调用其中一个函数：
template <typename F, typename... A>
void c (F&& f, A&&... a) {
f (std::forward<A>
浏览 1提问于2017-09-03得票数 4
1回答
我正在研究删除一些未使用的重载，并触发了一个编译错误，编译器说这是一个模板替换错误。但我认为“替换失败不是一个错误”，而且不管怎样，为什么移除重载会导致它？
简单的开始：
#include <string>
int ParseInt(const char *);
int ParseInt(std::string);
bool F(int(*)(const char *));
bool User() {
return F(ParseInt);
}
在这里，User()使用解析例程的地址调用F。平安无事。ParseInt是重载的，但只有一个重载与F的签名匹配。
输入F的模板重
浏览 0提问于2016-01-22得票数 4
2回答
重载前模板实例化中的错误
、、、、
给定以下代码
#include <type_traits>
#include <utility>
template <typename T>
class Something {
public:
template <typename F>
auto foo(F&&)
-> decltype(std::declval<F>()(std::declval<T&>())) {}
template <typename F>
auto foo(
浏览 3提问于2017-10-11得票数 3
回答已采纳
C++11在函数中引入了返回类型的箭头符号(不知道名称)：
template <typename T>
auto fun(T&& a) -> decltype(bar(a)){ ... }
但scott认为，使用auto作为返回类型本身将删除所有const和引用限定符(因为它遵循与模板演绎相同的模式)，因此惯用的方法是执行decltype(auto)，将所有限定符保持在类型的顶部。
但是，在这种情况下，auto是否被推断为decltype(bar(a))？那么decltype(auto)会是decltype(decltype(bar(a)))吗？这是多余的吗？
浏览 1提问于2018-07-31得票数 6
回答已采纳
C++标准14.8.2美元7美元：
替换发生在函数类型和模板参数声明中使用的所有类型和表达式中。表达式不仅包括常量表达式(如出现在数组边界中或作为非类型模板参数出现的表达式)，而且还包括sizeof、decltype和其他允许非常量表达式的上下文中的通用表达式(即非常数表达式)。替换按词法顺序进行，并在遇到导致扣减失败的条件时停止。注意:异常规范中的等效替换仅在异常规范实例化时进行，如果替换导致无效类型或表达式，则此时程序的格式不正确。-尾注
该标准在这里提供了一个示例：
template <class T> struct A { using X = typename T:
浏览 1提问于2016-08-16得票数 6
回答已采纳
2回答
与lambda尾随返回类型不一致
、、、、
考虑使用gcc-7.0.0最新快照的代码：
auto lambda1 = [](auto&& id) -> decltype(id == 10) { return id == 10; };
auto lambda2 = [](auto&& id) -> decltype(auto) { return id == 10; };
static_assert(!std::experimental::is_detected_v<ResultOfT,decltype(lambda1),std::string>);
//static_ass
浏览 3提问于2016-11-02得票数 2
回答已采纳
我将问题归纳为以下类，它试图使用std::enable_if禁用成员函数：
#include <type_traits>
int foo(int& x) {
return x;
}
template<bool enable>
struct A {
int x;
template<bool dummy=true,
typename Enabler = typename std::enable_if<dummy && enable>::type>
auto disabled_method() co
浏览 1提问于2017-06-22得票数 2
回答已采纳
以下是__dependent_type的定义：
template <class _Tp, bool>
struct _LIBCPP_TEMPLATE_VIS __dependent_type : public _Tp {};
所有用例：
/usr/.../c++/v1 >>> rg "_dependent_type"
浏览 0提问于2018-12-23得票数 1
回答已采纳
1回答
我不明白为什么未指定的lambda返回类型有时会起作用，但不会一直起作用。尤其是在这段代码中：
template <typename T>
concept NoArgFunc =
requires (T f) {
f();
};
auto curry(NoArgFunc auto&& f) {
return f();
}
auto curry(auto&& f) {
return [=](auto&& ...x) {
return curry([=](auto&&
浏览 30提问于2020-05-06得票数 3
回答已采纳
2回答
具有以下函数f0、f1、f2在C++14代码中，它接受任意数目的固定长度数组：
#include <functional>
template<typename... TS, size_t N> void f0( TS(&& ... args)[N] ) {}
template<typename T, size_t... NS> void f1( T(&& ... args)[NS] ) {}
template<typename... TS, size_t... NS> void f2( TS(&&
浏览 7提问于2022-09-18得票数 0
回答已采纳
1回答
当泛型lambda的实例化格式良好但不可编译时，我在检测它时遇到问题，而检测它使我感到困惑：
#include <functional>
class future
{
public:
int get() & { return 5; }
};
// Gets the return type of F(A), returning a not_well_formed type if not well formed
template<class F, class A> struct get_return_type
{
struct not_well_form
浏览 0提问于2015-07-12得票数 4
回答已采纳
考虑以下代码：
#include <iostream>
#include <functional>
int main() {
auto run = [](auto&& f, auto&& arg) {
f(std::forward<decltype(arg)>(arg));
};
auto foo = [](int &x) {};
int var;
auto run_foo = std::bind(run, foo, var);
run_foo();
浏览 0提问于2017-04-29得票数 24
回答已采纳
1回答
使用无效函数调用成功的概念检查
、、、、
在定义c++20概念以检查通过调用受约束的函数来满足需求时，g++和clang中的行为是不同的。如果检查函数无效，则g++接受类型，clang则相反：
// constrained function
template <class T>
constexpr void foo1(const T& type)
requires requires { type.foo(); }{}
// function with required expression in the body
template <class T>
constexpr auto foo2(co
浏览 6提问于2022-10-20得票数 1
回答已采纳
问题
我编写了一段复杂的模板代码，可以编译，但不能编译 (代码和错误链接)。
我认为这可能是的一个含义，但我无法看到它。
动机
我正在编写一个类，我希望它可以用两个不同类型的可调用函数来构造，但其中一个类被省略了，即：
my_class(callable_1);
my_class(callable_2);
my_class(callable_1, callable_2);
这应该没有问题。但是，为什么不允许callable_1和callable_2成为函数模板(或者使用operator()模板的函子)。也就是说，我想要这个(至少是最初想要的)：
my_class([](auto arg) {}
浏览 0提问于2018-10-27得票数 4
回答已采纳
1回答
我希望将任何类型的可调用(例如lambda)透明地包装在另一个可调用的内部，以注入额外的功能。包装器的类型应该具有与原始可调用的相同的特征：
相同参数类型
相同返回类型
传递参数的完美转发
在SFINAE结构中使用相同的行为
我试图使用通用的变量lambdas作为包装器：
#include <iostream>
#include <type_traits>
template<class TCallable>
auto wrap(TCallable&& callable) {
return [callable
浏览 0提问于2018-11-24得票数 5
回答已采纳
1回答
几个月来我一直在想这件事。我定义了一组概念，它们松散地描述容器和谓词。
通常，我使用老式的for循环遍历容器，并将参数迭代器与end(container)迭代器的相等性进行比较。我不明白的是，当给定一个Container<T>时，如果T没有一个相等比较器(T::operator==(T other))，它为什么不会编译？
这些概念一点也不完整，只是为了学习的目的，毫无疑问还有其他方法来完成我正在做的事情。
问题代码位于“queryorithms.h”中定义的这个简短的函数中：
#pragma once
#include <algorithm>
#include
浏览 2提问于2017-05-12得票数 0
回答已采纳
我理解为什么我们需要decltype(auto)，以及它与auto的区别，但我不明白为什么以及何时应该/需要使用decltype(expression)。在上的所有示例中，我都可以使用decltype(auto)，我检查了它。提前感谢您的帮助。
浏览 3提问于2020-07-15得票数 4
考虑以下函数对象l
auto l = [](auto x){ x.foo(); };
我可以成功地使用具有static_assert成员函数的类型调用它：
struct Foo { void foo(); };
static_assert(std::is_callable<decltype(l)(Foo)>{});
如果我使用的类型没有std::is_callable成员函数，那么现在我希望将std::false_type计算为.foo()：
static_assert(!std::is_callable<decltype(l)(int)>{});
不幸的是，上述sta
浏览 1提问于2017-03-11得票数 2
回答已采纳
2回答
下面的SFINAE代码使用clang3.7.1(C++14)很好地编译了各种模板：
#include <array>
#include <iostream>
#include <vector>
#include <cstdint>
enum class Bar : uint8_t {
ay, bee, see
};
struct S {
static void foo() {}
// std::begin(h) is defined for h of type H
template<typename H, typename.
浏览 5提问于2016-04-12得票数 16
回答已采纳
1回答
在以下几个方面是否有区别：
template <class T>
constexpr decltype(auto) f(T&& x) -> decltype(std::get<0>(std::forward<T>(x)))
{
return std::get<0>(std::forward<T>(x));
}
以及：
template <class T>
constexpr auto f(T&& x) -> decltype(std::get<0>(std::
浏览 1提问于2017-03-12得票数 4
回答已采纳
1回答
#include <iostream>
#include <type_traits>
template<typename T>
struct A
{
using m = std::remove_pointer_t<T>&;
};
template
<
typename T,
typename = std::void_t<>
>
struct Test
{
enum { value = 0 };
};
template<typename T>
struct Test&
浏览 3提问于2017-03-25得票数 0
回答已采纳
2回答
问题
在C++中传递它们时，是否有可能嵌套无捕获的羔羊？
据我所知，情况似乎并非如此；相反，您似乎必须创建一个模板类，并定义静态函数，然后传递这些函数。
背景
与这篇文章相关，用于pybind11：
基本上，我想看看是否可以避免宏，并仍然提供与Numpy UFunc API一起使用的无状态函数(没有任何类型擦除的UFunc恶作剧)。
我的目标是无状态的，因为API似乎有一些函数可以具有void* data，我可以使用这些函数指针传递另一个函数指针(或者用捕获来擦除lambda )，但其中一些函数似乎没有。
盲黑客
这是我的黑客攻击：
// Goal: Wrap a function of ty
浏览 0提问于2018-03-10得票数 2
回答已采纳
1回答
因为struct A不支持--运算符，所以下面的代码无法编译。
struct A {};
struct B {
void Run() {}
A& Dec(A& a) { return --a; }
};
int main(int argc, char** argv) {
B b;
b.Run();
}
这段代码也是如此。
struct A {};
template <class T>
struct B {
void Run() {}
A& Dec(A& a) { return --a; }
};
int main(in
浏览 0提问于2017-07-18得票数 8
4回答
std::get似乎对SFINAE不友好，如下测试用例所示：
template <class T, class C>
auto foo(C &c) -> decltype(std::get<T>(c)) {
return std::get<T>(c);
}
template <class>
void foo(...) { }
int main() {
std::tuple<int> tuple{42};
foo<int>(tuple); // Works fine
浏览 9提问于2017-01-17得票数 17
回答已采纳
我正在尝试使用std::invoke_result_t，当调用带有auto返回类型的函数中的嵌套lambda时，它会失败。这里是一个复制者：
template <typename T, typename... Args>
auto print_ret_type(T &&t, Args &&... args) {
using ret_type = std::invoke_result_t<T, Args...>;
std::cout << typeid(ret_type).name() << std::end
浏览 5提问于2021-07-05得票数 4
回答已采纳
2回答
我想找到Y坐标较小的点(如果有更多这样的点，找到X最小的那个)。当使用lambda编写它时：
std::min_element(begin, end, [](PointAndAngle& p1, PointAndAngle& p2) {
if (p1.first->y() < p2.first->y())
return true;
else if (p1.first->y() > p2.first->y())
return false;
e
浏览 0提问于2011-10-25得票数 21
回答已采纳
1回答
我正在试着写一个SFINAE模板来决定两个类是否可以添加在一起。这主要是为了更好地理解SFINAE是如何工作的，而不是出于任何特定的“现实世界”原因。
所以我想出的是
#include <assert.h>
struct Vec
{
Vec operator+(Vec v );
};
template<typename T1, typename T2>
struct CanBeAdded
{
struct One { char _[1]; };
struct Two { char _[2]; };
template<typename W>
浏览 0提问于2010-01-15得票数 4
回答已采纳
我最初有一个工作代码。在这个类中，我有这样的代码：
auto event =
std::dynamic_pointer_cast<EventA>(event);
现在，为了避免大量重复的代码，我用模板扩展了类。在新的实现中，我想这样做：
auto event_A_B = [&]() { //Event can be type EventA or type EventB
if (std::is_same<T, A>::value) {
return std::dynamic_pointer_cast<EventA>(event);
浏览 6提问于2022-01-03得票数 0
下面的代码使用MSVC编译器在Visual 2017中进行编译，但无法在GCC或Clang中编译。
#include <iostream>
#include <functional>
void functionTest(std::function<void()>) {
std::cout << "F\n";
}
void functionTest(bool) {
std::cout << "B\n";
}
int main() {
functionTest([](){ st
浏览 6提问于2017-08-09得票数 4
回答已采纳
1回答
结构，是基本模板，C++
、、、、
我想检查结构的模板参数是否是基本参数。所以我创建了一个结构
template<typename T, typename = std::enable_if<std::is_fundamental_v<T>>>
struct Something {
};
和一个空的结构
struct AStruct{
};
使用is_fundamental，我希望只有当模板参数T是long long int、float和其他基本类型之一时，我的结构才会被“启用”。
但当我做专业的时候
using Defined = Something<AStruct>;
它编译得
浏览 2提问于2020-12-11得票数 0
回答已采纳
2回答
到目前为止，std::optional有8个构造函数，如下所示(也在这里)
/* (1) */ constexpr optional() noexcept;
/* (1) */ constexpr optional( std::nullopt_t ) noexcept;
/* (2) */ constexpr optional( const optional& other );
/* (3) */ constexpr optional( optional&& other ) noexcept(/* see below */);
template < clas
浏览 3提问于2017-12-25得票数 5
回答已采纳
我对模板元编程相当陌生，并且一直在研究一些概念--然而，我遇到的这个特别的片段让我有点困惑。
template<class TAG, typename... DATATYPES>
struct Message {
Message (typename std::enable_if<sizeof...(DATATYPES) >= 1>) {
}
... (various other constructor declarations here)
std::tuple<DATATYPES...> m_data;
};
我在
浏览 1提问于2014-02-24得票数 1
回答已采纳
这是不允许的，因为它包含auto
void f(auto fp())
{
}
// error: 'auto' not allowed in function prototype
我们可以显式地将其设置为函数指针，并得到相同的错误：
void f(auto (*fp))
{
}
现在，如果我们给它一个尾随的返回类型：
void f(auto fp() -> int)
{
}
现在好了。这是合法的，是编译器错误还是疏忽？
有趣的是，它不允许我将auto函数指针作为参数。
// OK
void f(auto f(auto () -> int) -> int)
{
浏览 1提问于2016-06-07得票数 1
我发现gcc和clang允许在非类型模板参数类型子句中使用decltype(auto)。例如：
template <decltype(auto)>
struct X {};
int foo ;
int main() {
X<(foo)> x;
static_cast<void>(x);
}
它是符合标准的特性，还是一些？
浏览 4提问于2017-09-03得票数 45
回答已采纳
我遇到了std::is_convertible的，并对他们为什么要测试可返回性感到困惑。下面是全部实现的摘录。为什么要将nullptr转换为指向返回类型T的函数的指针？有没有不能返回的类型的例子？
template<class T>
auto test_returnable(int) -> decltype(
void(static_cast<T(*)()>(nullptr)), std::true_type{}
);
template<class>
auto test_returnable(...) -> std::false_type
浏览 2提问于2021-02-23得票数 2
2回答
类型特征和未评估的上下文
、、、
cppreference.com说的类型特征是：
如果表达式std::declval<T>() = std::declval<U>()在未计算上下文中格式良好，则提供成员常量值相等的true。对于任何其他类型，值都是false。类型T和U必须是完全对象类型、cv空值或未知界数组。访问检查就像从与任何类型无关的上下文中执行一样。
但代码：
template< std::size_t ...indices, std::size_t ...counter >
auto
invert_indices(std::index_sequence< count
浏览 5提问于2015-06-25得票数 2
此代码在g++ 4.9及更高版本(包括从svn构建)中失败，但在没有警告的情况下使用clang++和microsofts编译器(来自VS2015)进行编译。
#include <functional>
struct A {
void operator()() const {}
};
struct B {
void operator()() const {}
};
struct C : private A, private B
{
operator std::function<void()>() const { return nullptr; }
};
i
浏览 10提问于2016-11-20得票数 7
回答已采纳
如果传入模板的函数不包含有效参数，我如何使用enable_if禁用构造函数？
template <typename SrcType>
using is_Valid_Ret_Type = std::bool_constant<
std::is_same<SrcType, void>::value |
std::is_same<SrcType, int>::value>;
template <typename SrcType>
using is_Valid_Arg_Type = std::bool_constant<
浏览 12提问于2020-05-13得票数 0
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
云直播活动推荐
腾讯云开发者
