टेम्प्लेट टाइपनाम तर्क का संदर्भ कैसे दिया जाए

Question

क्या किसी टेम्पलेट टाइपनाम वाद के तर्क के रूप में संदर्भ पास करने का कोई तरीका है? मेरा मतलब है कि एक इंट पास करने के बजाय, उदाहरण के लिए, एक इंट का संदर्भ पास करना।

template <typename T>
struct Foo
{
    Foo(T arg) : ptr(arg) {}
    T ptr;
};

int main() 
{
    int* a = new int(6);
    Foo<decltype(a)> foo1(a); // ptr is a copy of a pointer
    Foo<decltype(&a)> foo1(&a); // ptr seems to be a pointer to a pointer
}

मुझे पता है कि मैं 'ptr' के सदस्य को कक्षा में T & T बनाकर एक पॉइंटर का संदर्भ बना सकता हूं, लेकिन मैं सोच रहा था कि क्या यह उस तर्क से किया जा सकता है जिसे टेम्प्लेट तर्क में पास किया गया है।

Comments

मुझे लगता है कि आप के साथ रहना चाहते हैं decltype, क्योंकि शीर्षक लेने का शाब्दिक अर्थ आप बस लिख सकते हैंFoo<int*&>

— idclev 463035818

Answer 1

तुम खोज रहे हो Foo<decltype(a) &> foo1(a)।

एक अधिक अस्पष्ट विकल्प (जो इस विशिष्ट मामले में काम करता है) है Foo<decltype((a))> foo1(a)।

Comments

आह कि समझ में आता है, धन्यवाद। डबल पैरेंटेस डिक्लेप्टाइप (ए) में कैसे काम करते हैं? यह एक संदर्भ कैसे बनता है?

— Zebrafish

@Zebrafish मूल रूप से, decltypeइस पर निर्भर करता है कि आप इसे एक चर नाम देते हैं या कुछ और (एक मनमाना अभिव्यक्ति)। decltype(a)वैरिएबल के प्रकार को लौटाता है a(क्योंकि आपने बस इसे वैरिएबल नाम दिया है)। decltype((a))दूसरी ओर, आपको अभिव्यक्ति का प्रकार देता है (a)(जो भी है int), जोड़ा संदर्भ-नेस के साथ जो अभिव्यक्ति के मूल्य श्रेणी को इंगित करता है। [१/२]

— १०:४३

(a)(साथ ही साथ a) एक लवल्यू है, जिसे संकेत दिया गया है &( &&xvalues द्वारा दर्शाया गया है , प्रचलन सभी प्रकार को नहीं बदलते हैं)। चूंकि अभिव्यक्तियों में संदर्भ प्रकार कभी नहीं होते हैं, इसलिए इस प्रकार के decltypeसंदर्भ-संदर्भ को जोड़ने से तथ्य किसी भी टकराव का कारण नहीं बन सकता है। [२/२]

— होलीब्लैककैट

Answer 2

पिछले उत्तर के विकल्प के रूप में, आप std :: reference_wrapper का उपयोग कर सकते हैं

std :: reference_wrapper एक क्लास टेम्प्लेट है जो एक कॉपी करने योग्य, असाइन करने योग्य ऑब्जेक्ट में एक संदर्भ लपेटता है। इसे अक्सर मानक कंटेनरों (जैसे std :: वेक्टर) के अंदर संदर्भों को संग्रहीत करने के लिए एक तंत्र के रूप में उपयोग किया जाता है, जो आमतौर पर संदर्भों को पकड़ नहीं सकता है।

#include <functional>

template <typename T>
struct Foo
{
  Foo(T arg) : ptr(arg)
  {
  }
  T ptr;
};

int main()
{
  int* a = new int(6);

  Foo<std::reference_wrapper<int*>> foo1(std::ref(a));
  foo1.ptr[0] = 1;  // ok

  // This also works
  int* b = new int(6);
  Foo<std::reference_wrapper<decltype(b)>> foo2(std::ref(b));
  // and this too
  foo1 = foo2;

  // Or, if you use c++17, even this
  Foo foo3(std::ref(b));
}