Mẫu biến thể - các loại mở rộng khác nhau

Question

Andrei Alexandrescu đã có một bài nói chuyện tuyệt vời mang tên: Variadic Templates are Funadic.

Ông trình bày 3 mở rộng sau đó là subltey khác nhau:

template <class... Ts> void fun(Ts... vs) { 
    gun(A<Ts...>::hun(vs)...); 
    gun(A<Ts...>::hun(vs...)); 
    gun(A<Ts>::hun(vs)...); 
} 

Ông giải thích:

Gọi 1: Mở rộng tất cả Ts cho instatiation của class A, Sau đó gọi hun(vs) Sau đó mở rộng tất cả các thông số một lần nữa khi chuyển chúng vào gun

Gọi 2: Mở rộng tất cả Ts và tất cả vs riêng

Gọi 3: Expnads trong bước khóa, ví dụ: Mở rộng tranh luận 1 trong tổng số Ts và Đối số 1 của vs Mở rộng tranh luận 2 Ts và đối số 2 của vs Mở rộng đối n của Ts và lập luận n của vs

thảo luận khác về templ variadic ates chỉ dường như bao gồm các mẫu lớp đơn giản của variadic và các hàm variadic như typesafe printf, v.v. Tôi không chắc chắn về cách các kiểu mở rộng khác nhau này có hiệu lực như thế nào và mỗi loại sẽ hữu ích ở đâu.

Có ai có một số ví dụ minh họa ứng dụng của từng loại mở rộng không?

Answer 1

#include <iostream> 
#include <memory> 
#include <typeinfo> 
#include <cstdlib> 
#include <cxxabi.h> 

template <typename T> 
std::unique_ptr<char, void(*)(void*)> 
type_name() 
{ 
    return std::unique_ptr<char, void(*)(void*)> 
      (
       __cxxabiv1::__cxa_demangle(typeid(T).name(), nullptr, 
              nullptr, nullptr), 
       std::free 
      ); 
} 

void display() {} 

template <class T> 
void 
display() 
{ 
    std::cout << type_name<T>().get() << ' '; 
} 

template <class T, class T2, class ...Tail> 
void 
display() 
{ 
    std::cout << type_name<T>().get() << ' '; 
    display<T2, Tail...>(); 
} 

template <class... Ts> 
struct A 
{ 
    template <class... Us> 
     static 
     int 
     hun(Us... us) 
     { 
      std::cout << "A<"; 
      display<Ts...>(); 
      std::cout << ">::hun("; 
      display<Us...>(); 
      std::cout << ")\n"; 
      return 0; 
     } 
}; 

template <class ...T> 
void gun(T...) {} 

template <class... Ts> void fun(Ts... vs) 
{ 
    std::cout << "gun(A<Ts...>::hun(vs)...);\n"; 
    gun(A<Ts...>::hun(vs)...); 
    std::cout << "\ngun(A<Ts...>::hun(vs...));\n"; 
    gun(A<Ts...>::hun(vs...)); 
    std::cout << "\ngun(A<Ts>::hun(vs)...);\n"; 
    gun(A<Ts>::hun(vs)...); 
} 

int main() 
{ 
    fun(1, 'a', 2.3); 
} 

Output:

gun(A<Ts...>::hun(vs)...); 
A<int char double >::hun(int) 
A<int char double >::hun(char) 
A<int char double >::hun(double) 

gun(A<Ts...>::hun(vs...)); 
A<int char double >::hun(int char double) 

gun(A<Ts>::hun(vs)...); 
A<int >::hun(int) 
A<char >::hun(char) 
A<double >::hun(double) 

Answer 2

Các trường hợp 2 và 3 thực sự là rất phổ biến trong bất kỳ loại mã liên quan đến gói variadic.

template<typename... T> 
void f(T&&... t) 
{ 
    // Case 2: 
    auto t2 = std::tuple<T...>(t...); 

    // Case 3: 
    auto t3 = std::make_tuple(std::forward<T>(t)...); 
} 

Nhìn vào mã của riêng tôi, tôi không thể tìm thấy bất kỳ ví dụ còn lại của trường hợp 1. Tôi có thể đã sử dụng nó trong quá khứ ở một số detail namespace cho một tempate helper, nhưng tôi không chắc chắn. Tôi không nghĩ rằng nó sẽ là phổ biến hoặc thậm chí cần thiết hầu hết thời gian.