c++ - क्या पीछे की वापसी प्रकार वाक्यविन्यास शैली नए सी++ 11 प्रोग्राम के लिए डिफ़ॉल्ट होनी चाहिए?




c++11 auto (3)

सी ++ 11 एक नए फ़ंक्शन सिंटैक्स का समर्थन करता है:

auto func_name(int x, int y) -> int;

वर्तमान में इस समारोह को घोषित किया जाएगा:

int func_name(int x, int y);

नई शैली को व्यापक रूप से अभी तक नहीं माना जाता है (जीसीसी एसएलएल में कहें)

हालांकि, क्या इस नई शैली को नए सी ++ 11-प्रोग्राम्स में हर जगह प्राथमिकता दी जानी चाहिए, या जब आवश्यकता हो तो इसका उपयोग किया जाएगा?

निजी तौर पर, जब संभव हो तो मैं पुरानी शैली पसंद करता हूं, लेकिन मिश्रित शैलियों के साथ कोड-बेस बहुत बदसूरत दिखता है।


एक और फायदा यह है कि जब फ़ंक्शन किसी फ़ंक्शन पर पॉइंटर लौटाता है तो पीछे-वापसी-प्रकार सिंटैक्स अधिक पठनीय हो सकता है। उदाहरण के लिए, तुलना करें

void (*get_func_on(int i))(int);

साथ में

auto get_func_on(int i) -> void (*)(int);

हालांकि, कोई तर्क दे सकता है कि फ़ंक्शन पॉइंटर के लिए एक प्रकार उपनाम शुरू करके बेहतर पठनीयता प्राप्त की जा सकती है:

using FuncPtr = void (*)(int);
FuncPtr get_func_on(int i);

कुछ ऐसे मामले हैं जहां आपको पिछली वापसी प्रकार का उपयोग करना होगा। सबसे विशेष रूप से, यदि निर्दिष्ट किया गया है, तो एक लैम्ब्डा रिटर्न प्रकार, पीछे की वापसी प्रकार के माध्यम से निर्दिष्ट किया जाना चाहिए। साथ ही, यदि आपका रिटर्न टाइप एक decltype का उपयोग करता है decltype लिए तर्क नाम दायरे में हैं, तो पीछे की ओर लौटने का उपयोग किया जाना चाहिए (हालांकि, आमतौर पर कोई भी इस बाद के मुद्दे के आसपास काम करने के लिए declval<T> का उपयोग कर सकता है)।

पिछली वापसी के प्रकार में कुछ अन्य मामूली फायदे हैं। उदाहरण के लिए, पारंपरिक फ़ंक्शन सिंटैक्स का उपयोग करके एक गैर-इनलाइन सदस्य फ़ंक्शन परिभाषा पर विचार करें:

struct my_awesome_type
{
    typedef std::vector<int> integer_sequence;

    integer_sequence get_integers() const;
}; 

my_awesome_type::integer_sequence my_awesome_type::get_integers() const
{
    // ...
}

सदस्य typedefs दायरे में नहीं हैं जब तक कक्षा के नाम ::get_integers से पहले प्रकट नहीं हो ::get_integers , इसलिए हमें कक्षा योग्यता दो बार दोहराना होगा। यदि हम पिछली वापसी प्रकार का उपयोग करते हैं, तो हमें इस प्रकार के नाम को दोहराने की आवश्यकता नहीं है:

auto my_awesome_type::get_integers() const -> integer_sequence
{
    // ...
}

इस उदाहरण में, यह इतना बड़ा सौदा नहीं है, लेकिन यदि आपके पास कक्षा के टेम्पलेट्स के लंबे वर्ग के नाम या सदस्य कार्य हैं जिन्हें इनलाइन परिभाषित नहीं किया गया है, तो यह पठनीयता में एक बड़ा अंतर डाल सकता है।

सी ++ नाओ 2012 में अपने "ताजा पेंट" सत्र में, एलिसडेयर मेरिडिथ ने इंगित किया कि यदि आप निरंतर वापसी प्रकारों का लगातार उपयोग करते हैं, तो आपके सभी कार्यों के नाम अच्छी तरह से पंक्तिबद्ध होते हैं:

auto foo() -> int;
auto bar() -> really_long_typedef_name;

मैंने CxxReflect में हर जगह पिछला रिटर्न प्रकार का उपयोग किया है, इसलिए यदि आप एक उदाहरण की तलाश कर रहे हैं कि कोड लगातार उनका उपयोग कैसे करता है, तो आप वहां एक नज़र डाल सकते हैं (उदाहरण के लिए, type क्लास )।


यह अच्छा लेख देखें: http://www.cprogramming.com/c++11/c++11-auto-decltype-return-value-after-function.html गेम में अस्वीकार किए बिना इस वाक्यविन्यास का उपयोग करने के लिए बहुत अच्छा उदाहरण :

class Person
{
public:
    enum PersonType { ADULT, CHILD, SENIOR };
    void setPersonType (PersonType person_type);
    PersonType getPersonType ();
private:
    PersonType _person_type;
};

auto Person::getPersonType () -> PersonType
{
    return _person_type;
}

और एलेक्स एलन के लेख से भी शानदार स्पष्टीकरण चोरी हो गया "क्योंकि रिटर्न वैल्यू फ़ंक्शन के अंत में जाती है, इसके बजाए, आपको कक्षा के दायरे को जोड़ने की आवश्यकता नहीं होती है।"

इस संभावित मामले की तुलना करें जब दुर्घटना से कोई वर्ग वर्ग के बारे में भूल जाता है, और, बड़ी आपदा के लिए, वैश्विक स्कोप में एक और व्यक्ति टाइप परिभाषित किया जाता है:

typedef float PersonType; // just for even more trouble
/*missing: Person::*/
PersonType Person::getPersonType ()
{
    return _person_type;
}




trailing-return-type