完美轉發和std ::元組

Question

考慮下面的代碼：

#include <iostream> 
#include <tuple> 
#include <utility> 

// A. 
template <typename... Args> 
void f (const char* msg, Args&&... args) 
{ 
    std::cout << "A. " << msg << "\n"; 
} 

// B. 
template <typename... Args> 
void f (const char* msg, std::tuple<Args...>&& t) 
{ 
    std::cout << "B. " << msg << "\n"; 
} 

struct boo 
{ 
    const std::tuple<int, int, long> g() const 
    { 
     return std::make_tuple(2, 4, 12345); 
    } 
}; 

int main() 
{ 
    f("First", 2, 5, 12345); 
    f("Second", std::make_tuple(2, 5, 12345)); 

    boo the_boo; 
    f("Third", the_boo.g()); 
    f("Fourth", std::forward<decltype(std::declval<boo>().g())>(the_boo.g())); 

    return 0; 
} 

的輸出將是：

A. First 
B. Second 
A. Third 
A. Fourth 

從它的明顯，它不這樣做，我想什麼輸出它要做的，就是我想第三個和第四個要經過B.版本的函數。 The std ::轉發從第四電話是多餘的，因爲完美的轉發不會發生在那裏。爲了擁有完美的轉發我知道：

• 我必須在一個類型推導上下文
• 參數的類型的右值引用必須是功能

我明白了一個模板類型這是行不通的。但我不充分掌握：

• 爲什麼上下文是通過使用的std ::元組在這樣一種方式，它不能根據需要工作改變了嗎？爲什麼模板參數不能用於另一個模板類型的 ？

• 我該如何（優雅地）修復它？

Answer 1

你的問題是在第三和第四你傳遞一個const std::tuple其中B.期望非const版本。

當編譯器試圖生成調用f代碼，它認爲你是一個const std::tuple電話等演繹的Args...類型爲const std::tuple。調用B.是無效的，因爲變量具有與預期不同的常量限定。

要解決這個問題，只需讓g()返回一個非const元組。

---

編輯：對發生的完美轉發

爲了，你需要一個推斷背景下，正如你在你的問題。當你在函數參數列表中說std::tuple<Args...>&&時，推導出Args...，但是std::tuple<Args...>&&不是;它可以只有由右值引用。爲了解決這個問題，該論點需要採用T&&的形式，其中推導出T。

我們可以使用自定義類型特質做到：

template <typename T> 
struct is_tuple : std::false_type {}; 

template <typename... Args> 
struct is_tuple <std::tuple<Args...>> : std::true_type {}; 

然後我們利用這個特點來啓用僅元組單參數模板：

// B. 
template <typename T, typename = typename std::enable_if< 
          is_tuple<typename std::decay<T>::type>::value 
          >::type> 
void f (const char* msg, T&& t) 
{ 
    std::cout << "B. " << msg << "\n"; 
    std::cout << "B. is lval == " << std::is_lvalue_reference<T>() << "\n"; 
} 

或者：

//! Tests if T is a specialization of Template 
template <typename T, template <typename...> class Template> 
struct is_specialization_of : std::false_type {}; 

template <template <typename...> class Template, typename... Args> 
struct is_specialization_of<Template<Args...>, Template> : std::true_type {}; 

template <typename T> 
using is_tuple = is_specialization_of<T, std::tuple>; 

is_specialization_of取自here並由this question建議。

現在我們有完美的轉發！

int main() 
{ 
    f("First", 2, 5, 12345); 
    f("Second", std::make_tuple(2, 5, 12345)); 

    boo the_boo; 
    f("Third", the_boo.g()); 
    f("Fourth", std::forward<decltype(std::declval<boo>().g())>(the_boo.g())); 

    auto the_g = the_boo.g(); 
    f("Fifth", the_g); 

    return 0; 
} 

輸出：

A. First 
B. Second 
B. is lval == 0 
B. Third 
B. is lval == 0 
B. Fourth 
B. is lval == 0 
B. Fifth 
B. is lval == 1