विषय पर बढ़ें

अंतिम अद्यतन：2026-10-12

C++ decltype टाइप deduction

लेखक के बारे में:

व्यक्तिगत WeChat सार्वजनिक अकाउंट:

wechat

1.बुनियादी उपयोग

decltype का syntax है:

decltype (expression)

यहाँ कोष्ठक ज़रूरी हैं, decltype का काम है "expression का टाइप पूछना", इसलिए ऊपर के statement का प्रभाव यह है कि expression एक्सप्रेशन का टाइप लौटाना। ध्यान दें, decltype केवल एक्सप्रेशन का टाइप "पूछता" है, एक्सप्रेशन का "मूल्यांकन" नहीं करता।

1.1 एक्सप्रेशन का टाइप deduce करना

int i = 4;
decltype(i) a; //推导结果为int。a的类型为int。

1.2 using/typedef के साथ उपयोग, टाइप परिभाषित करने के लिए।

using size_t = decltype(sizeof(0));//sizeof(a)的返回值为size_t类型
using ptrdiff_t = decltype((int*)0 - (int*)0);
using nullptr_t = decltype(nullptr);
vector<int >vec;
typedef decltype(vec.begin()) vectype;
for (vectype i = vec.begin; i != vec.end(); i++)
{
//...
}

इस तरह auto की तरह, इससे भी कोड की पठनीयता बढ़ती है।

1.3 anonymous टाइप का पुनः उपयोग

C++ में हमें कभी-कभी कुछ anonymous टाइप मिलते हैं, जैसे:

struct 
{
    int d ;
    double b;
}anon_s;

और decltype की मदद से हम इस anonymous स्ट्रक्चर का दोबारा उपयोग कर सकते हैं:

decltype(anon_s) as ;//定义了一个上面匿名的结构体

1.4 generic programming में auto के साथ, फ़ंक्शन के रिटर्न टाइप track करने के लिए

यही decltype का सबसे बड़ा उपयोग है।

template <typename T>
auto multiply(T x, T y)->decltype(x*y)
{
    return x*y;
}

पूरा कोड देखें: decltype.cpp

2.निर्णय नियम

decltype(e) के लिए, इसका निर्णय परिणाम निम्नलिखित शर्तों से प्रभावित होता है:

अगर e बिना कोष्ठक वाला id-expression या क्लास मेंबर एक्सेस एक्सप्रेशन है, तो decltype(e) उस entity का टाइप होगा जिसे e नाम देता है। इसके अलावा, अगर e एक overloaded फ़ंक्शन है, तो compile error होगा। वरना, मान लीजिए e का टाइप T है, अगर e एक xvalue है, तो decltype(e) होगा T&& वरना, मान लीजिए e का टाइप T है, अगर e एक lvalue है, तो decltype(e) होगा T&। वरना, मान लीजिए e का टाइप T है, तो decltype(e) होगा T।

id से तात्पर्य कीवर्ड, literal आदि कंपाइलर के उपयोग वाले चिह्नों के अलावा प्रोग्रामर द्वारा खुद परिभाषित नामों से है, और एकल id से जुड़ा एक्सप्रेशन id-expression कहलाता है। उदाहरण के लिए: 

int arr[4]
तो arr एक id-expression है, जबकि arr[3]+0 नहीं।

उदाहरण नीचे दिए गए हैं:

int i = 4;
int arr[5] = { 0 };
int *ptr = arr;
struct S{ double d; }s ;
void Overloaded(int);
void Overloaded(char);//重载的函数
int && RvalRef();
const bool Func(int);

//规则一：推导为其类型
decltype (arr) var1; //int[] 标记符表达式

decltype (ptr) var2;//int *  标记符表达式

decltype(s.d) var3;//doubel 成员访问表达式

//decltype(Overloaded) var4;//重载函数。编译错误。

//规则二：将亡值。推导为类型的右值引用。

decltype (RvalRef()) var5 = 1;

//规则三：左值，推导为类型的引用。

decltype ((i))var6 = i;     //int&

decltype (true ? i : i) var7 = i; //int&  条件表达式返回左值。

decltype (++i) var8 = i; //int&  ++i返回i的左值。

decltype(arr[5]) var9 = i;//int&. []操作返回左值

decltype(*ptr)var10 = i;//int& *操作返回左值

decltype("hello")var11 = "hello"; //const char(&)[9]  字符串字面常量为左值，且为const左值。


//规则四：以上都不是，则推导为本类型

decltype(1) var12;//const int

decltype(Func(1)) var13=true;//const bool

decltype(i++) var14 = i;//int i++返回右值

सीखने के लिए रेफ़रेंस: https://www.cnblogs.com/QG-whz/p/4952980.html

संबंधित विषय

टिप्पणियाँ