C++
एकदम सही अग्रेषण

टिप्पणियों

template<class T>
void f(T&& x) // x is a forwarding reference, because T is deduced from a call to f()
{
    g(std::forward<T>(x)); // g() will receive an lvalue or an rvalue, depending on x
}

template<class T>
struct a
{
    a(T&& x); // x is a rvalue reference, not a forwarding reference
};

a example1(1);
  // same as a<int> example1(1);

int x = 1;
a example2(x);
  // same as a<int&> example2(x);

कारखाने के कार्य

मान लीजिए कि हम एक फ़ैक्टरी फ़ंक्शन लिखना चाहते हैं जो तर्कों की एक मनमानी सूची को स्वीकार करता है और उन तर्कों को किसी अन्य फ़ंक्शन के लिए अनमॉडिफाइड पास करता है। ऐसे फ़ंक्शन का एक उदाहरण make_unique , जिसका उपयोग सुरक्षित रूप से T एक नए इंस्टेंस का निर्माण करने के लिए किया जाता है और एक unique_ptr<T> है जो इंस्टेंस का स्वामी है।

वैरेडिक टेम्प्लेट और रैवल्यू रेफरेंस के बारे में भाषा के नियम हमें इस तरह के फ़ंक्शन को लिखने की अनुमति देते हैं।

template<class T, class... A>
unique_ptr<T> make_unique(A&&... args)
{
    return unique_ptr<T>(new T(std::forward<A>(args)...));
}

दीर्घवृत्त का उपयोग ... एक पैरामीटर पैक को इंगित करता है, जो प्रकार की एक मनमानी संख्या का प्रतिनिधित्व करता है। कंपाइलर इस पैरामीटर पैक को कॉल साइट पर तर्क की सही संख्या तक विस्तारित करेगा। ये तर्क तब std::forward का उपयोग करते हुए T के कंस्ट्रक्टर में std::forward । इस फ़ंक्शन को तर्कों के रेफ-क्वालिफायर को संरक्षित करना आवश्यक है।

struct foo
{
    foo() {}
    foo(const foo&) {}                    // copy constructor
    foo(foo&&) {}                         // copy constructor
    foo(int, int, int) {}
};

foo f;
auto p1 = make_unique<foo>(f);            // calls foo::foo(const foo&)
auto p2 = make_unique<foo>(std::move(f)); // calls foo::foo(foo&&)
auto p3 = make_unique<foo>(1, 2, 3);