int main(){
decltype(auto)&& a = 100;
}
以上代码，是GCC和Clang中的一个错误。
int main(){
decltype(int)&& a = 100;
}
这个代码是正确的。
在N4296中，
第8.3.2/6节
如果ty胡枝子(7.1.3)、类型模板参数(14.3.1)或解密类型说明符(7.1.6.2)表示引用类型T的类型TR，则试图创建类型“lvalue引用cv”的尝试会创建类型“lvalue引用T”，而尝试创建类型“rvalue引用cv”则会创建类型TR。
第7.1.6.2节中的解密型
浏览 2提问于2015-01-04得票数 4
回答已采纳
int myfun()
{
return 42;
}
我知道我可以写
auto myvar = myfun();
但是，如果我只想声明myvar (不使用公共typedef)呢？
the_type_returned_by_myfun myvar;
可以写什么来代替the_type_returned_by_myfun
浏览 0提问于2011-12-22得票数 23
回答已采纳
首先，我构造了四个结构，每个结构返回value，l-value引用，const l-value引用，r-value引用。我在包装器(B或C)中使用它们，在这些包装器的方法func()中，我希望保留A的func()的引用和cv限定符。
在c++11中，我使用了尾随返回类型。但是随着c++14中正常返回类型演绎的到来，我猜我可以跳过后面的部分，但只有在使用auto时，返回类型才会像普通的auto一样忽略限定符和引用。
那么，我的问题是，在行为类似于下面的B类的c++14中实现它的最佳方式是什么？有时编写尾部(通常是decltype(返回表达式))会让人沮丧，因为它是微不足道的。
struct A1
浏览 1提问于2013-05-30得票数 5
回答已采纳
1回答
我已经注意到，我不能使用类实例c执行&decltype(c)::f来获取指向成员函数f的指针，但是我可以使用类类型C执行&C::f来获取指向成员函数的指针，我相信它与decltype(c)相同。
请看这个最小的例子：
struct C{
int f()
{
return 5;
}
} c;
template<typename T, T t, typename S, S*s> void callCf()
{
(s->*t)();
}
int main()
{
callCf<decltype(&
浏览 0提问于2020-10-07得票数 1
1回答
我对c++中的TMP比较陌生。我想知道是否有一种方法可以为classes(not 实例实现一个容器！)在c++中(17，没有boost或c++20，最好是。)
下面是我要找的东西：
int integer = 0xDEADBEEF;
std::string hello ("hello");
boost::any c (integer);
const int c_deadbeef = integer;
int& cr_deadbeef (integer);
using oneClassContainer = decltype( makeClassContainer(in
浏览 3提问于2021-07-19得票数 0
回答已采纳
解密类型(1+2)是否声明xvalue或prvalue？
an首选项表示，decltype(表达式)将声明: 1. T& if表达式是xvalue 2. t如果表达式是prvalue 3. t& if表达式是lvalue。
但我的问题是:如何生成xvalue表达式？在我的实验中，我认为返回值和temp对象应该是xvalue，但实际上它们似乎是xvalue：
struct S{};
S f();
int main()
{
int i=2;
decltype(i+1) j=i;
++j;
printf("i=%d\n",i);
浏览 3提问于2017-04-17得票数 2
回答已采纳
1回答
我有点不明白为什么带逗号运算符的decltype在某些情况下返回引用类型。
例如，在此代码中：
int i = 101;
decltype(1, i) var = i;
var = 20;
printf("%d\n", i); // will print 20
在这里，var是int&而不是int，但是如果我将第二行替换为：
decltype(i) var = i;
它会回来的！
有人能解释一下吗？
浏览 2提问于2014-08-07得票数 5
回答已采纳
1回答
(对此问题进行了大量编辑，对不起。)
假设我有几个非constexpr函数模板，它们默认为被删除：
template <typename T> void foo() = delete;
template <typename T> int bar(int x) = delete;
// etc.
并有一些明确的专门化作为一般情况删除的例外。
我想写代码(例如特征类？)给定这些函数之一和类型T的标识符，在编译时检测指定的函数是否显式地指定为T类型，代码需要是泛型的，即每个函数不需要单独的检测器。
备注：
寻找C++11解决方案。
我们可以假设指定的函数在默认情况下
浏览 7提问于2020-04-03得票数 1
1回答
所以我有一个类，它接受两个模板参数，一个是类型，一个是使用函数的类型，它有一个约简函数重复应用到数组中。但是，我得到了一个编译错误。
function_template_test.cpp: In instantiation of 'class _C<int, int(int, int)>':
function_template_test.cpp:36:33: required from here
function_template_test.cpp:11:17: error: field '_C<int, int(int, int)>::op
浏览 0提问于2019-12-09得票数 1
回答已采纳
1回答
情况是这样的：
{
MyStruct * foo;
// works perfectly! When I change MyStruct to MyOtherStruct then
// I do not have to change the sizeof expression.
foo = (MyStruct *) malloc(sizeof(decltype(*foo)));
// The cast has to be adapted.
}
对于强制转换的(MyStruct *)，我如何实现这个通用语法？我试了很多次，但没有运气。
使用C++11
更新：，根据
浏览 0提问于2015-07-06得票数 0
回答已采纳
2回答
基于SFINAE的模板检测方法
、、、、
我有一个简单的特性struct hasMemberSerialize，我试图用它来确定任何给定的类是否与callSerialize()兼容。struct看起来是这样的：
template<typename Type, typename ArchiveType>
struct hasMemberSerialize {
template<typename T, typename A>
static auto test(int) -> decltype(Serialization::access::callSerialize(std::declval&l
浏览 1提问于2018-10-14得票数 1
回答已采纳
1回答
我一直没能找到一个很好的解密解释。请告诉我，作为一个初级程序员，它做什么和为什么它是有用的。
例如，我正在读一本书，其中提出了以下问题。有人能给我解释一下答案吗?为什么，还有一些好的(初级的)例子？
当代码完成时，每个变量的类型是什么，每个变量有什么值？
int a= 3，b= 4；解密型(A)c= a；解密型((B))d= a；++c；++d；
逐行解释会很有帮助。
浏览 4提问于2013-09-15得票数 84
回答已采纳
我很少看到decltype(auto)，但当我这样做时，我感到困惑，因为当函数返回时，它似乎与auto做了相同的事情。
auto g() { return expr; }
decltype(auto) g() { return expr; }
这两种语法有什么区别？
浏览 4提问于2014-01-26得票数 66
回答已采纳
1回答
我试图更好地理解解密类型，以便在编译时确定表达式的类型。比方说，我用一个双变量来完成这个任务：
#include <iostream>
#include <type_traits>
int main(){
double a;
typedef decltype(a) a_type;
typedef decltype((a)) ref_a_type;
typedef decltype(a)& o_ref_a_type;
a_type b;
ref_a_type c = b;
o_ref_a_type d =
浏览 3提问于2016-04-09得票数 6
回答已采纳
1回答
假设我们有：
template <typename T>
void foo(std::vector<T> &t) {
auto var = T();
std::vector<decltype(var.Get())> array;
}
在上面的代码中，创建了一个数组。此数组的类型与Get()的返回值无关。我们通过创建一个T类型的伪变量，然后使用decltype推断Get的返回类型来找到这个值。
这是可行的，但是它需要创建一个没有任何用途的伪变量。
相反，我们可以这样做：
template <typename T>
void
浏览 12提问于2019-08-12得票数 4
回答已采纳
考虑以下代码片段：
if constexpr (std::is_rvalue_reference_v<decltype(collection)>)
{
auto view =
Ranges::Views::CopyView
<std::remove_reference_t<decltype(collection)>, ValType>(collection);
static_assert(std::input_iterator<decltype(view.begin())>);
static_assert
浏览 10提问于2022-03-20得票数 0
1回答
我有：
#include <type_traits>
#include <stdio.h>
void f() { printf("foo\n"); }
int main()
{
printf("%d %d %d\n",
std::is_same<decltype(*&f),decltype(f)>::value,
std::is_function<decltype(*&f)>::value,
std::is_function<decltype(f)>::v
浏览 2提问于2012-02-27得票数 4
2回答
我有以下代码：
template<auto... args> struct Custom
{
};
int main()
{
Custom<1, nullptr> s; // i want this to succeed only when all the template arguments are of the same type
}
从上面的代码可以看出，我可以传递不同类型的模板参数。我的问题是，是否有一种方法只接受相同类型的模板参数。这意味着，main中的语句应该失败，并且只在所有模板参数都是相同类型时才能工作。实质上，有两项要求：
对于少于
浏览 16提问于2022-03-26得票数 0
回答已采纳
我读过很多次关于解密(X)和解密((X))之间的区别的文章。一个例子如下所示。
X是变量的名称，所以解密类型(X)是int。但是在圆括号中包装名称x-“(X)”-yields-一个比名称更复杂的表达式。作为一个名称，x是一个lvalue，C++也将表达式(x)定义为lvalue。因此，解密类型((X))是int&。在名称周围加上括号可以更改其解密报告的类型！
有人能给我看一个变量的输出吗，比如x，其中解密类型(X)和解密类型((Xx))的输出类型不同？我需要一个显式显示输出差异的示例。
我很感激你。谢谢。
浏览 3提问于2015-10-12得票数 0
1回答
创建给定字符中指定类型的对象
、、、、
我的头文件定义了多个具有单个字符名称的类；即A类、B类、C类等。每个类都支持.getname()，它将类名作为字符返回，给定一个随机生成的字符，我遇到了使用模板返回大小的问题。
到目前为止，我还不知道如何在给定char值的情况下定义类类型。
我希望下面的代码能够打印出A类的大小，为了简化起见，我将testChar赋给了'A'，但实际上它可以是任何存在匹配类名的随机字符；
class A
{
private:
char name;
public:
A(){name='A';}
char getName(){return name;}
};
浏览 13提问于2021-11-04得票数 0
如果我从第三方代码中得到以下代码：
template <typename T>
class MemberType
{
public:
using const_ptr = const T*;
};
struct SchemaA
{
MemberType<int> *m_1;
MemberType<double> *m_2;
// more data members that I don't care for
MemberType<double> *m_3;
MemberType<do
浏览 1提问于2017-05-12得票数 1
回答已采纳
1回答
有没有一个补丁(官方的或非官方的)让IntelliSense停止将decltype的每一次使用都作为语法错误报告？它编译得很好，所以我知道decltype是受支持的，但是看到到处都是红色的乱七八糟的东西很让人分心，使得在代码中发现实际的错误变得更加困难。每个编译都给出了数百个非错误的列表--基本上在代码库中每次使用decltype时至少有3个错误，例如：
std::for_each(std::begin(list), std::end(list), [](const decltype(list)::value_type& item)
{
<do stuff with it
浏览 3提问于2016-03-15得票数 3
1回答
解密说明符的用途
、、、
我正在读关于查询限定名的条款。其中有一段引语：
如果嵌套名称说明符中的:：作用域解析操作符前面没有解密类型说明符，则查找以下名称:只考虑名称空间、类型和专门化为类型的模板。
正如标准decltype-specifier中所定义的那样：
decltype-specifier:
decltype ( expression )
decltype ( auto )
这是什么意思？你能解释一下那个关键词的用途吗？
浏览 3提问于2014-06-02得票数 8
回答已采纳
2回答
所以我有个例子
auto a = getMyTuple();
它最终将成为真正的std：：tuple<类型(一些args)> )。
现在我想把它存储在一个有模板的类中，因为我还不知道它的类型。与…有关的东西
template<typename T>
class my_tuple
{
public:
T mt;
my_tuple(T t)
{
mt = t;
}
};
我的问题是，是否有一种方法可以获得auto返回的类型，这样我就可以将它传递到模板类中，例如
my_tuple<getType(a)> myTup(a);
浏览 4提问于2016-05-16得票数 3
回答已采纳
2回答
我正在尝试声明一个变量，以便它的类型与我有成员函数指针的成员函数的返回类型相同。
class Widget {
public:
std::chrono::milliseconds Foo();
};
例如，给定一个指向Widget::Foo的成员函数指针fn，我如何声明一个变量blah，以便它获得Widget::Foo的返回类型(std::chrono::milliseconds)？
我从一篇使用<type_traits>的result_of和decltype的博客文章中找到了一些有希望的指导，但我似乎无法让它工作。
auto fn = &Widge
浏览 0提问于2015-03-22得票数 10
回答已采纳
在C++中有没有一种方法(或函数)来创建在运行时确定类型的指针。例如:有一个类型为Base的指针*ptr。假设我们有一个函数getType，它能够返回作为参数传递的指针的类型。getType(ptr)，它返回指针的类型，以便我可以使用它来创建类似类型的指针，例如
getType(ptr) *newPtr=new getType(ptr)();.
在C++中有什么方法可以做到这一点吗？
浏览 15提问于2020-02-16得票数 1
2回答
我想测试一个变量类型的属性。我可以，但是代码太冗长了。
考虑一个示例，其中我定义了一个与容器中值的类型相同的变量：
#include <vector>
int main() {
std::vector<int> v, &rv=v;
// ‘rv’ is not a class, namespace, or enumeration
//rv::value_type i1;
// Ok
decltype(v)::value_type i2;
// decltype evaluates to ‘std::vector<int>
浏览 4提问于2016-09-12得票数 4
回答已采纳
我试图通过一个堆栈溢出问题( C++ )来理解中的解密类型。
已被接受的部分答案如下。
int foo();
int n = 10;
decltype(n) a = 20; // a is an "int" [id-expression]
decltype((n)) b = a; // b is an "int &" [(n) is an lvalue]
decltype(foo()) c = foo(); // c is an "int" [rvalue]
decltype
浏览 6提问于2021-02-16得票数 1
回答已采纳
1回答
C++中的函数和函数指针
、、、、
引用以下代码
#include <iostream>
using std::cout;
using std::endl;
#include <vector>
using std::vector;
void function() {
cout << "Hello World" << endl;
}
int main() {
vector<void (*) ()> functions;
functions.push_back(function); // (1) no error
浏览 0提问于2016-02-03得票数 3
回答已采纳
2回答
如何推导嵌套容器值类型
、、、
我有一个容器可以储存另一个容器。我需要在嵌套容器的值之上为这个容器创建一个迭代器。这个迭代器应该定义一个operator*，但是我不知道嵌套容器的值类型要返回。我不能保证容器有任何typedef的值。唯一给出的是每个容器都有一个合适的operator[]。如何声明operator*
template<typename ContainerType>
struct MyIterator{
MyIterator(ContainerType& container, int32 indexA = 0, int32 indexB = 0)
: Container(contain
浏览 5提问于2016-05-13得票数 3
回答已采纳
下面的函数创建了一个lambda，它使用第一个可调用对象的结果调用第二个可调用对象。如果第一个可调用对象返回一个元组，它将应用于第二个可调用对象。
template<typename T>
struct is_tuple : std::false_type{};
template<typename... T>
struct is_tuple<std::tuple<T...>> : std::true_type{};
template<typename S, typename T>
constexpr decltype(auto)
浏览 0提问于2018-03-31得票数 4
1回答
我有个练习：
auto p = 42;
auto const& q = p;
auto r = q;
auto& s = q;
r和s的类型是什么？
这是我的答案，但我不太确定：
auto p = 42; // int
auto const& q = p; // const int&
auto r = q; // int&
auto& s = q; // int&&
浏览 2提问于2019-10-04得票数 0
假设我有这样一门课：
struct MyStruct
{
template<typename T>
static int Func()
{
// Do something with the template parameter.
}
};
现在假设我想用Func的prototype创建指向函数的指针向量。由于原型不依赖于模板参数，所以应该是可能的。而且，果然，我可以显式地typedef一个指向Func的指针，如下所示：
typedef int (* FuncPtr)(MyStruct * pointer);
然后，创建向量就像：
st
浏览 9提问于2015-08-16得票数 1
回答已采纳
1回答
模板函数的包装器
、、
我所要做的是：
// or any templated function
template <typename... Args>
void function(Args... args) {}
// wrapper
void launch(???) { ??? }
int main()
{
// first option
launch(function, 1, 2, 3, 4);
// second option
launch<function>(1, 2, 3, 4);
}
据我所知，第一个选项是不可能的，因为我必须传递专门的模板函数
浏览 0提问于2019-05-23得票数 2
回答已采纳
为什么这个片段不编译？
#include <iostream>
#include <vector>
#include <ranges>
#include <unordered_map>
namespace vw = std::ranges::views;
int main()
{
auto get_second = [](auto&& pair) constexpr noexcept -> decltype(auto)
{ return std::forward<
浏览 1提问于2020-09-03得票数 2
回答已采纳
2回答
解密(Auto)有什么用途？
、、、、
在c++14中引入了decltype(auto)成语。
通常，它的用途是允许auto decltype 声明在给定表达式上使用decltype规则。
搜索这个成语的“好”用法的例子，我只能想到如下(由编写)，即--一个函数的返回类型演绎
template<typename ContainerType, typename IndexType> // C++14
decltype(auto) grab(ContainerType&& container, IndexType&& index)
{
authenticate
浏览 3提问于2014-06-08得票数 203
回答已采纳
void foo(int a) {
cout << "Hello" << a << '\n';
}
根据解密类型的规则，解密类型(Foo)应该是"void (Int)“，但似乎我们对它无能为力：
void (& f_ref)(int) = foo;
void (* f_ptr)(int) = foo;
cout<<is_same_v<decltype(foo), decltype(f_ref)><<endl; //return 0
cout<<is_s
浏览 0提问于2018-03-02得票数 2
回答已采纳
如果decltype(auto)和decltype(returning expression)作为函数(模板)的返回类型(模板)，在这两种情况下使用没有括号的expr有什么区别？
auto f() -> decltype(auto) { return expr; } // 1
auto f() -> decltype(expr) { return expr; } // 2
上面的f可以在任何上下文中定义/声明，可以是(成员)函数或(成员)函数模板，甚至(泛型) lambda。expr可以依赖于任何模板参数。
在第二个版本中，两个expr都是完全相同的表达式，没有额外的括号。
在C+
浏览 7提问于2016-11-04得票数 16
回答已采纳
2回答
SFINAE检测静态法
、、、、
我正在尝试实现一种机制来检测提供的类是否包含一些静态方法。这是相当简单的代码，但我不明白为什么decltype()不像EnableIfHasFooMethod类的专门化那样工作：
#include <iostream>
struct A {
static int Foo() { return 0; }
};
template <class T, class = void>
struct EnableIfHasFooMethod {};
template <class T>
struct EnableIfHasFooMethod<T, de
浏览 2提问于2017-10-08得票数 4
回答已采纳
1回答
因此，我从一个API中获取一个变量，我们将它称为long foo，并将它传递给另一个API，后者将它作为值：int bar。
在中，这些内容实际上是相同的：
但这会引发：
static_assert(is_same_v<decltype(foo), decltype(bar)>);
因为即使它们实际上是相同的，它们也不是相同的类型。除了使用数值限制库将long与int匹配之外，是否有其他解决办法？
浏览 0提问于2019-01-02得票数 0
回答已采纳
3回答
为什么这段代码会产生错误的输出？
//this-type.cpp
#include <iostream>
#include <type_traits>
using namespace std;
template<typename testype>
class A
{
public:
A()
{
cout << boolalpha;
cout << is_same<decltype(*this), A<int>>::value << endl;
浏览 0提问于2012-12-12得票数 5
回答已采纳
1回答
下面是我代码的一部分：
int getLength(const vector<int> &arr) {
auto n=arr.size(),dis=n;
unordered_map<int,decltype(dis)> S;
//...
}
到目前一切尚好。现在，我没有为我的std::unordered_map硬编码“std::unordered_map”，而是尝试将其更改为：unordered_map<decltype(arr.front()),decltype(dis)> S;、unordered_map<decl
浏览 0提问于2019-04-17得票数 2
回答已采纳
1回答
方法指针与一致性
、、、
考虑以下假设示例：
template<typename T, typename R, typename... Ps>
R call(T& t, R (T::*method)(Ps...), Ps... ps){
return (t.*method)(ps...);
}
struct A{
int f(int i) const {return i;}
};
A a;
那么call(a, &A::f, 3)就不会编译，因为f是const。我是否可以在不提供以下重载的情况下使call工作：
template<typename T, typename
浏览 4提问于2022-10-07得票数 -3
回答已采纳
1回答
当我取消容器的迭代器(例如*v.begin())时，我总是得到对包含的类型的引用。然后，我不能使用decltype初始化另一个容器。
int main()
{
vector<int> a;
vector<decltype(*a.begin())> b;
return 0;
}
我该怎么解决这个问题？
浏览 0提问于2017-02-16得票数 0
回答已采纳
1回答
以下代码是用VC++ Nov 2012 CTP编译的。但是编译器给出了一个警告。
我只是想知道这是不是VC++ 2012年11月CTP的一个bug。
struct A
{
int n;
A(int n)
: n(n)
{}
int Get() const
{
return n;
}
int Get()
{
//
// If using "static_cast<const A&>(*this).Get();" instead,
浏览 0提问于2013-02-28得票数 8
回答已采纳
移位运算符：<< >>按位运算符：~，&，^，|大小运算符：sizeof()
根据C++标准(n3797)，我只能确认~产生prvalue (5.3.1/2)，而不是上面的其他值。
浏览 0提问于2014-07-02得票数 3
3回答
我刚刚看到了鲍里斯·贾布斯( Boris )的“ Rock Hard: C++”的演变。在有关高阶泛型编程的一节中，他说，下面是一个函数的示例，它的返回类型更通用，导致模板函数重载较少。
template <typename Func>
auto deduce(const Func & f) -> decltype(f())
{..}
但是，这可以使用普通模板语法实现，如下所示
template <typename Func>
Func deduce(const Func & f)
{..}
所以我想选择的例子并不能真正显示出decltype的独特
浏览 2提问于2011-10-01得票数 15
回答已采纳
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
回答已采纳
1回答
我正试图解决一个大学问题，它要求我们编写一个接受参数的函数: Type1容器，包含Type2容器，包含Type3容器，这些容器包含任意类型的元素。容器类型不必不同，但所知道的只是它们只支持少数几个函数(例如size( ))，而且所有维度都是相同的。到目前为止，我们只处理了序列容器，所以我想他们将用定制的序列容器来测试这一点。
我需要的是一个返回包含Type2容器的Type1容器的函数。我试着用这样的构造：
template <typename Cube>
auto foo(const Cube &bar) -> remove_reference<decl
浏览 1提问于2017-04-23得票数 0
回答已采纳
1回答
C++自由函数可以别名吗？
、、、、
我有一个具有高度模板的免费函数的命名空间，如：
namespace a
{
template<typename T, typename K, typename H>
void f(T t, K k, std::vector<H> h_vec = {})
{ /* body */ }
}
在另一个名称空间中，为了方便起见，我想为一些特定用法提供一些别名，例如：
namespace b
{
using my_specific_f = a::f<int,string,char>;
}
这将允许我为函数提供更好的命名，因为f在我正在开
浏览 2提问于2019-03-28得票数 4
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
