पॉइंटर्स में एक std tuple अनपॅकिंग?

Question

मान लीजिए मैं एक टपल

std::tuple<A, B, C> myFavoriteTuple; 

मैं यह कर सकता है:

A a; 
B b; 
C c; 
std::tie(a, b, c) = myFavoriteTuple 

लेकिन इन tuples के कुछ वास्तव में कॉपी करने के लिए महंगे हैं, तो क्या मैं वास्तव में चाहते हैं के लिए एक संदर्भ या लेने के लिए है मेरे tuple में सही धब्बे के लिए एक सूचक। मैं यह कर सकता:

A* a = &std::get<0>(myFavoriteTuple); 
B* b = &std::get<1>(myFavoriteTuple); 
C* c = &std::get<2>(myFavoriteTuple); 

लेकिन वह कैसे भयानक tie वाक्य रचना है की तुलना में इतना लंगड़ा लगता है। क्या ट्यूपल घटकों के पॉइंटर्स/संदर्भ प्राप्त करने का कोई और तरीका है?

Answer 1

सामान्य सूचकांक बुनियादी ढांचे को देखते हुए:

template<int... Is> 
struct seq { }; 

template<int N, int... Is> 
struct gen_seq : gen_seq<N - 1, N - 1, Is...> { }; 

template<int... Is> 
struct gen_seq<0, Is...> : seq<Is...> { }; 

आप एक समारोह है कि संकेत के एक टपल देता है, बना सकते हैं प्रत्येक तत्व इनपुट टपल की इसी तत्व के लिए सूचक किया जा रहा है:

template<typename... Args, int... Is> 
auto make_pointer_tuple(std::tuple<Args...>& t, seq<Is...>) 
    -> std::tuple<typename std::add_pointer<Args>::type...> 
{ 
    return std::make_tuple(&std::get<Is>(t)...); 
} 

template<typename... Args> 
auto make_pointer_tuple(std::tuple<Args...>& t) 
    -> std::tuple<typename std::add_pointer<Args>::type...> 
{ 
    return make_pointer_tuple(t, gen_seq<sizeof...(Args)>()); 
} 

और इस प्रकार आप इसका उपयोग कर सकते हैं:

std::tuple<int, bool, std::string> myFavoriteTuple{0, false, ""}; 

int* pInt = nullptr; 
bool* pBool = nullptr; 
std::string* pString = nullptr; 
tie(pInt, pBool, pString) = make_pointer_tuple(myFavoriteTuple); 

यहां एक 0 है।

Answer 2

निम्नलिखित के बारे में क्या?

template<typename T> 
struct ptie 
{ 
    const T *ptr; 
    ptie() 
     :ptr(nullptr) 
    {} 

    void operator=(const T &x) 
    { 
     ptr = &x; 
    } 
}; 

ptie<A> a; 
ptie<B> b; 
ptie<C> c; 
std::tie(a, b, c) = myFavoriteTuple; 

फिर आप ऑब्जेक्ट तक पहुंचने के लिए *a.ptr का उपयोग कर सकते हैं। यदि आप इसे महसूस करते हैं तो आप operator-> आदि को ओवरराइड भी कर सकते हैं।

इस विधि का मुख्य दोष यह है कि यह operator=(const T&) की वजह से टुपल सदस्यों को const के रूप में बांधता है। आप इसे ptr = const_cast<T*>(x) से निकाल सकते हैं लेकिन मुझे लगता है कि कुछ मामलों में कॉन्स्ट-शुद्धता तोड़ सकती है।