為什么std::decltype回傳對命名左值物件的參考？

我在 Scott Meyer 的 Effective C 中讀到，對于 T 型別的左值運算式而不是名稱，decltype總是報告一種型別T&，我似乎理解（這里也有解釋）。但是，我看到在某些設定下，當decltype在類的某種型別 Y 的非靜態命名成員變數上呼叫時，結果型別是 aY&而不是Y我看起來不尋常的型別。

下面是下面的代碼。背景：我正在嘗試使用 SFINAE 根據回傳型別排除模板函式多載。這是完整的代碼。

#include<iostream>
#include<stdio.h>
#include<string>
#include<typeinfo>
class foo
{
    public:
    using  type1  = std::string;
    std::string someFun();
    std::string somestring;
};

//OVERLOAD 1
//Type T must have a function T::size()
template<typename T>
auto testFun(T& t) ->decltype((void) (t.size()),t.somestring)
{
    std::string hello1{"helloworld"};
    return hello1;
}

//OVERLOAD 2
//Type T must have a function T::someFun()
template<typename T>
// auto testFun(T& t) ->decltype((void) (t.someFun()),t.someFun())       //4
auto testFun(T& t) ->decltype((void) (t.someFun()),t.somestring)   //3
{
    std::cout<<std::boolalpha;
    std::cout<<std::is_same<std::string, decltype(t.somestring)>::value<<std::endl; //5
    std::string hello{"helloWorld"};
    return hello;
}

int main()
{
    foo f1;
    testFun(f1);
    return 0;
}

說明：我們有 2 個多載testFun（參見評論 OVERLOAD 1 和 OVERLOAD2）。

對于 的當前實作foo，呼叫 OVERLOAD2 是因為它期望存在一個someFun在 foo.h 中宣告的函式。此外，此多載的回傳型別由 給出decltype((void) (t.someFun()),t.somestring)，它回傳型別為 的型別t.somestring，即std::string。但是，當我嘗試按原樣編譯該函式時，它給了我編譯警告，并且沒有創建任何可執行檔案。

warning: reference to local variable 'hello' returned [-Wreturn-local-addr]
     std::string hello{"helloWorld"};

這讓我相信 的回傳型別testFun(params)被推斷為是std::string&而不是std::string。為什么呢 ？

此外，如果我注釋該行//3并取消注釋//4，則代碼編譯良好并且行//5輸出true，這證實了 的型別decltype(t.somestring)確實沒有參考限定。那么為什么原始設定（line //3 uncomment , line //4 commented）不起作用？

uj5u.com熱心網友回復：

tl;博士：

• ((void) (t.someFun()),t.somestring)不是id-expression，因此以下規則適用：

  ^(1.4) - 如果E是 xvalue, decltype(E)is T&&, 其中T是 的型別E;
  ^(1.5) - 如果E是左值，decltype(E)則是T&，其中T是 的型別E；
  ^(1.6) - 否則，decltype(E)是 的型別E。

• ((void) (t.someFun()),t.somestring)是一個左值，所以它的 decltype 是std::string&根據（1.5）。
• ((void) (t.someFun()),t.someFun())是一個純右值，所以它的 decltype 是std::string根據 (1.6)。

長說明

1. 逗號運算子

讓我們從逗號運算子的結果型別開始：

7.6.20 逗號運算子（強調我的）

⁽¹⁾一對用逗號分隔的運算式從左到右求值；左邊的運算式是一個丟棄值運算式。左邊的運算式排在右邊的運算式之前（[intro.execution]）。結果的型別和值就是右運算元的型別和值；結果與其右運算元屬于相同的值類別，并且如果其右運算元是位域，則結果是位域。

所以逗號運算子的結果將是它的正確運算元（包括它的值類別 - 所以如果正確的運算元是左值，那么逗號運算子的結果將是）

2.價值類別 t.somestring

那么結果會((void) (t.someFun()),t.somestring)怎樣呢？

這是一個類成員訪問，因此以下適用：

7.6.1.5 類成員訪問（重點是我的）

^{(3) 將}postfix-expression.id-expression 簡寫為E1.E2，E1 稱為物件運算式。
[...]
⁽⁶⁾如果 E2 被宣告為具有“對 T 的參考”型別，那么 E1.E2 是一個左值；E1.E2 的型別為 T。否則，適用以下規則之一。
[...]
^(6.1)如果 E2 是非靜態資料成員且 E1 的型別為“cq1 vq1 X”，且 E2 的型別為“cq2 vq2 T”，則運算式指定相應成員子物件由第一個運算式指定的物件。如果 E1 是左值，則 E1.E2 是左值；否則 E1.E2 是 xvalue。[...]

因此，鑒于它t是一個左值（您將其宣告為T& t），我們可以得出結論，它t.somestring也必須是一個左值。
（如果你寫過例如((void) (t.someFun()),std::move(t).somestring)結果將是一個 xvalue）

3.價值類別 t.someFun()

鑒于這是一個函式呼叫，我們可以直接跳到函式呼叫的結果應該是什么：

7.6.1.3 函式呼叫

⁽¹⁴⁾如果結果型別是左值參考型別或函式型別的右值參考，則函式呼叫是左值，如果結果型別是物件型別的右值參考，則是xvalue，否則是純右值。

鑒于someFun()按值回傳，最后一種情況適用：結果將是一個純右值。

4. 結果型別來自 decltype(...)

9.2.9.5 Decltype 說明符

⁽¹⁾ For an expression E, the type denoted by decltype(E) is defined as follows:

• ^(1.1) if E is an unparenthesized id-expression naming a structured binding ([dcl.struct.bind]), decltype(E) is the referenced type as given in the specification of the structured binding declaration;
• ^(1.2) otherwise, if E is an unparenthesized id-expression naming a non-type template-parameter ([temp.param]), decltype(E) is the type of the template-parameter after performing any necessary type deduction ([dcl.spec.auto], [dcl.type.class.deduct]);
• ^(1.3) otherwise, if E is an unparenthesized id-expression or an unparenthesized class member access ([expr.ref]), decltype(E) is the type of the entity named by E. If there is no such entity, the program is ill-formed;
• ^(1.4) otherwise, if E is an xvalue, decltype(E) is T&&, where T is the type of E;
• ^(1.5) otherwise, if E is an lvalue, decltype(E) is T&, where T is the type of E;
• ^(1.6) otherwise, decltype(E) is the type of E.

4.1 decltype(t.somestring)

decltype(t.somestring) satisfies (1.3) (it is an unparenthesized class member access).

So it's result is the type of t.somestring -> std::string.

4.2 decltype((void) (t.someFun()),t.somestring)

decltype((void) (t.someFun()),t.somestring) doesn't satisfy (1.1) - (1.3) since it isn't an id-expression.

So it must be one of the last 3 cases ( (1.4) - (1.6) )

Given that the type of t.somestring is std::string and the result of the comma operator is an lvalue in this case, we need to apply (1.5).

So the result is std::string&.

4.3 decltype((void) (t.someFun()),t.someFun())

Same as above we can eliminate the first 3 cases since the expression is not an id-expression.

The result of t.someFun() was a prvalue, so neither (1.4) nor (1.5) apply.

So the only option that's left is (1.6), and the result is std::string.

5. A few more examples

A few more examples to demonstrate it:

// case 1: xvalue (1.4)
using K = decltype(((void)0, foo{}.somestring));
// K == std::string&&

// case 2: lvalue (1.5)
foo f{};
using K = decltype(((void)0, f.somestring));
// K == std::string&

// case 3: prvalue (1.6)
using K = decltype(((void)0, std::string{"A"}));
// K == std::string

A better C 20 approach

With C 20 we now have require clauses which make those checks a lot easier (and the error messages you get won't be quite as cryptic as the SFINAE ones)

例如，您可以像這樣撰寫這些檢查：

Godbolt 示例

template<class T>
  requires requires(T& t) { t.size(); }
auto testFun(T& t)
{
    std::cout << "size()" << std::endl;
    /* ... */
}

template<class T>
  requires requires(T& t) { t.someFun(); }
auto testFun(T& t)
{
    std::cout << "someFun()" << std::endl;
    /* ... */
}

如果您愿意，也可以將其分解為概念，如果您想重用它：

Godbolt 示例

template<class T>
concept Sizeable = requires(T& t) {
    t.size();
};

template<class T>
concept SomeFunAble = requires(T& t) {
    t.someFun();
};


template<Sizeable T>
auto testFun(T& t)
{
    std::cout << "size()" << std::endl;
    /* ... */
}

template<SomeFunAble T>
auto testFun(T& t)
{
    std::cout << "someFun()" << std::endl;
    /* ... */
}

uj5u.com熱心網友回復：

[dcl.type.simple]/4對于運算式e， 所表示的型別decltype(e)定義如下：

(4.2) — 否則，如果e是無括號的id 運算式或無括號的類成員訪問 (8.2.5)，decltype(e)則是由e
(4.4)命名的物體的型別— 否則，如果e是左值，decltype(e)則是T&，其中T是型別的e

您似乎希望decltype((void) (t.someFun()),t.someFun())像 (4.2) 專案符號中描述的那樣行為 - 但它的引數實際上不是無括號的 id 運算式或類成員訪問。因此，它遵循子彈 (4.4) 并生成型別std::string&。另一方面，decltype(t.somestring)確實遵循 (4.2) 并產生std::string; 這里的運算元是一個無括號的類成員訪問。

標籤：C 模板 细纹 声明类型

上一篇：在一個簡單的CRTP案例中沒有名為“XXX”的成員

下一篇：在具有默認模板引數的函式模板上獲取具有自動推導回傳型別的指標