Chuyên mẫu với con trỏ hàm, mà phụ thuộc vào tham số mẫu

Question

Tôi muốn có một mẫu với một giá trị lồng nhau mà phải được khởi tạo bởi một hàm khởi tạo đưa ra:

template <typename T, T(INIT)()> struct Foo 
{ 
    T value = INIT(); 
}; 

Nó có thể được sử dụng theo cách này:

// Some random type only instanceable through factory() 
struct Bar 
{ 
    int bar{}; 
private: 
    // The only way to create a Bar is through factory() 
    friend Bar factory(); 
    Bar() {}; 
}; 

Bar factory() { return {}; } 

Foo<Bar, factory> foo; 

Nhưng, nếu không có chức năng được cung cấp, các mẫu nên cố gắng mặc định khởi tạo các giá trị lồng nhau, vì vậy tôi đã cố gắng để chuyên template:

template <typename T> struct Foo<T, nullptr> 
{ 
    T value{}; 
}; 

Ý tưởng là để sử dụng nó theo cách này:

struct Baz{}; 

Foo<Bar, factory> foo; // Nested Bar have Bar::bar initialized through factory function. 
Foo<Baz>   baz; // No factory function needed, nested Baz default-initialized. 

Nhưng tôi chỉ phát hiện ra rằng mẫu loại chuyên môn hóa một phần không thể dựa trên các loại mẫu khác, lỗi tôi nhận được dán bên dưới:

error: type 'T (*)()' of template argument 'nullptr' depends on a template parameter template struct Foo

---

Có cách nào để đạt được mục tiêu của mình không? Sẽ tốt hơn nếu nó hoạt động với các biến mẫu:

template <typename T, T(INIT)()> T Foo = INIT(); 
template <typename T>   T Foo<T, nullptr>{}; 

Câu hỏi bổ sung: Tại sao một phần chuyên môn không thể phụ thuộc vào thông số mẫu? Lý do đằng sau hạn chế này là gì?

Answer 1

Nếu nó chỉ về việc khởi tạo mặc định nếu tham số mẫu thứ hai bị thiếu, bạn có thể cung cấp chức năng khởi tạo mặc định theo khuôn mẫu làm tham số mặc định như.

template<typename T> 
    T do_default_assign() { 
     return T(); 
    };                  

template <typename T, T (INIT)() = do_default_assign<T> > struct Foo 
    { 
     T value = INIT(); 
    }; 

này tuy nhiên bị một không cần thiết "trở lại theo giá trị" và hoạt động chuyển nhượng mà có thể tốn kém hoặc không thể đối với một số T.

Answer 2

Đối với trường hợp của bạn, bạn có thể sử dụng:

template <typename T> 
T default_construct() { return T{}; } 

template <typename T, T(INIT)() = &default_construct<T>> 
struct Foo 
{ 
    T value = INIT(); 
}; 

Và sau đó sử dụng nó như:

Foo<int> f; 
Foo<int, bar> b; 

Live demo

Answer 3

Bạn có thể định nghĩa một hàm constructor mẫu mà sẽ khởi tạo một giá trị kiểu Type và sau đó sử dụng nó như một constructor mặc định:

template<typename Type, typename... Args> 
Type constructor(Args... args) { 
    return Type(std::forward<Args>(args)...); 
} 

và sau đó sử dụng nó như là mẫu mặc định tham số cho hàm:

template <typename T, T(INIT)() = constructor<T>> struct Foo 
{ 
    T value = INIT(); 
}; 

Live demo