在結構型注射

Question

我認爲這是不可能的什麼，我問，但我想是完全確定的，所以我問反正..

我想從一個模板結構得到一個編譯時間值（可以在constexpr函數中使用），但是沒有在模板中傳遞，但以其他方式注入。

這是很難解釋，我會用一些代碼嘗試：

template<int A> 
struct MagicStruct 
{ 
enum { current = A, injected = /* magic */} 
}; 

template<int A, int B> 
struct InjectionStruct 
{ 
enum { first=A, second=B} 
/*... injection of B in MagicStruct<A> ... */ 
}; 

static const int AVALUE = 1; 
static const int BVALUE = 2; 

static const int CVALUE = InjectionStruct<AVALUE, BVALUE>::first; //== 1 
static const int CVALUE = InjectionStruct<AVALUE, BVALUE>::second; //== 2 
static const int DVALUE = MagicStruct<AVALUE>::injection; //== 2 

有一些訣竅，我不知道這將允許？

[編輯]我想在輸入獲得DVALUE只是作爲安勤模板參數

Answer 1

你可以做injected成static int代替：

template<int A> 
struct MagicStruct 
{ 
    enum { current = A }; 
    static int injected; 
}; 

template<int A> 
int MagicStruct<A>::injected; 

然後給InjectionStruct靜態成員，其實例將在MagicStruct<A>::injected填寫：

template<int A, int B> 
struct InjectionStruct : MagicStruct<A> 
{ 
    enum { first=A, second=B}; 

    struct filler { 
     filler() { MagicStruct<A>::injected = B; } 
    }; 

    static filler inject; 
}; 

template <int A, int B> 
typename InjectionStruct<A,B>::filler InjectionStruct<A,B>::inject; 

然後進行注射，你只需要在某處使用inject，或者明確地實例化它：

static const int AVALUE = 1; 
static const int BVALUE = 2; 

static const int CVALUE = InjectionStruct<AVALUE, BVALUE>::first; //== 1 
static const int DVALUE = InjectionStruct<AVALUE, BVALUE>::second; //== 2 
//explicit instantiation 
template InjectionStruct<AVALUE,BVALUE>::filler 
     InjectionStruct<AVALUE,BVALUE>::inject; 
static const int EVALUE = MagicStruct<AVALUE>::injected; //== 2 

或者，你可以隱藏在injected您使用檢索first或second一些功能的實例。

---

這是一個瘋狂的實現，它依賴於通過模板實例化注入函數的實現。這可能不是你的編譯器的工作，如果它不執行有關標準正確的規則，但它是有趣儘管如此，在編譯時完全透明的工作原理：

template<typename>struct Type{}; 

template<int A> 
struct MagicStruct 
{ 
    friend constexpr int get_injected(Type<MagicStruct<A>>); 
    static constexpr int current() { return A; } 

    template <int V = get_injected(Type<MagicStruct<A>>{})> 
    static constexpr int injected() { return V; } 
}; 


template<int A, int B> 
struct InjectionStruct 
{ 
    static constexpr int first() { return A; } 
    static constexpr int second() { return B; } 

    friend constexpr int get_injected(Type<MagicStruct<A>>) { return B; } 
}; 

你這個實現使用幾乎完全一樣，你想：

static const int AVALUE = 1; 
static const int BVALUE = 2; 

static const int CVALUE = InjectionStruct<AVALUE, BVALUE>::first(); //== 1 
static const int DVALUE = InjectionStruct<AVALUE, BVALUE>::second(); //== 2 
static const int EVALUE = MagicStruct<AVALUE>::injected(); //== 2 

Live demo

Answer 2

將在下面幫你？

template<int A, int B> 
struct InjectionStruct 
{ 
    constexpr static int first = A; 
    constexpr static int second = B; 
    constexpr static int MAGIC = B; 
}; 

template<int A, class Injection> 
struct MagicStruct 
{ 
    constexpr static int current = A; 
    constexpr static auto injected = Injection::MAGIC; 
}; 
static const int AVALUE = 1; 
static const int BVALUE = 2; 

static const int CVALUE = InjectionStruct<AVALUE, BVALUE>::first; //== 1 
static const int CVALUE = InjectionStruct<AVALUE, BVALUE>::second; //== 2 
static const int DVALUE = MagicStruct<AVALUE, InjectionStruct<AVALUE, BVALUE>>::injected; //== 2 

很難給出更深入的建議，不知道你想要注入什麼。

Answer 3

您需要InjectionStruct和MagicStruct之間的一些關係。出於這個原因，我在injected值中包含了一個額外的模板參數，在InjectionStruct中包含了typdef。

第一個例子使用InjectionStruct本身定義的特定MagicStruct：

實施例：

// MagicStruct is generic 
template<int A, int INJ> 
struct MagicStruct 
{ 
    enum { current = A, injected = INJ}; 

}; 

// Injection struct has it own copy of MagicStruct 
template<int A, int B> 
struct InjectionStruct 
{ 
    enum { first=A, second=B}; 

    // Provide custom magic number 
    constexpr static int provideInjection(){ return B;} 

    // Own copy of magicStruct, injected by this template instance. 
    template <int X> struct MagicStruct: public ::MagicStruct<X,provideInjection()>{}; 
}; 

constexpr static const int AVALUE = 1; 
constexpr static const int BVALUE = 2; 

constexpr static const int CVALUE1 = InjectionStruct<AVALUE, BVALUE>::first; //== 1 
constexpr static const int CVALUE2 = InjectionStruct<AVALUE, BVALUE>::second; //== 2 
// Using a specific InjectionStruct, provies the MagicStruct with one argument. 
constexpr static const int DVALUE3 = InjectionStruct<AVALUE, BVALUE>::MagicStruct<AVALUE>::injected; //== 2 


int main() 
{ 
    std::cout << CVALUE1 << std::endl; 
    std::cout << CVALUE2 << std::endl; 
    std::cout << DVALUE3 << std::endl; 

    return 0; 
} 

在下面的溶液中，MagicStruct把它魔法值從默認InjectionStruct這是修復。

// InjectionStruct is generic. 
template<int A, int B> 
struct InjectionStruct 
{ 
    enum { first=A, second=B}; 
    constexpr static int provideInjection(){ return A+B;} 
}; 


constexpr static const int AVALUE = 1; 
constexpr static const int BVALUE = 2; 

// Define MagicStruct based on a specific InjectionStruct 
template<int A, int INJ = InjectionStruct<A,BVALUE>::provideInjection()> 
struct MagicStruct 
{ 
    enum { current = A, injected = INJ}; 
}; 

constexpr static const int CVALUE1 = InjectionStruct<AVALUE, BVALUE>::first; //== 1 
constexpr static const int CVALUE2 = InjectionStruct<AVALUE, BVALUE>::second; //== 2 
constexpr static const int DVALUE1 = MagicStruct<3>::injected; // == 5 
constexpr static const int DVALUE2 = MagicStruct<DVALUE1>::injected; // == 7 
constexpr static const int DVALUE3 = MagicStruct<DVALUE2>::injected; // == 9 


int main(int n, char* args[]) 
{ 
    std::cout << CVALUE1 << std::endl; 
    std::cout << CVALUE2 << std::endl; 
    std::cout << DVALUE1 << std::endl; 
    std::cout << DVALUE2 << std::endl; 
    std::cout << DVALUE3 << std::endl; 

    return 0; 
}