मैं समान कॉन्स और गैर-कॉन्स सदस्य कार्यों के बीच कोड डुप्लिकेशन कैसे हटा सकता हूं?

Question

चलो कहते हैं कि मैं निम्नलिखित class X जहाँ मैं एक आंतरिक सदस्य के लिए उपयोग वापस जाने के लिए चाहते हैं:

class Z 
{ 
    // details 
}; 

class X 
{ 
    std::vector<Z> vecZ; 

public: 
    Z& Z(size_t index) 
    { 
     // massive amounts of code for validating index 

     Z& ret = vecZ[index]; 

     // even more code for determining that the Z instance 
     // at index is *exactly* the right sort of Z (a process 
     // which involves calculating leap years in which 
     // religious holidays fall on Tuesdays for 
     // the next thousand years or so) 

     return ret; 
    } 
    const Z& Z(size_t index) const 
    { 
     // identical to non-const X::Z(), except printed in 
     // a lighter shade of gray since 
     // we're running low on toner by this point 
    } 
}; 

दो सदस्य कार्यों X::Z() और X::Z() const ब्रेसिज़ के अंदर समान कोड है। यह डुप्लिकेट कोड है और जटिल तर्क के साथ लंबे कार्यों के लिए रखरखाव की समस्याएं पैदा कर सकता है।

क्या इस कोड डुप्लिकेशन से बचने का कोई तरीका है?

Answer 1

हां, कोड डुप्लिकेशन से बचना संभव है। आपको तर्क रखने के लिए कॉन्स्ट सदस्य फ़ंक्शन का उपयोग करने की आवश्यकता है और गैर-कॉन्स्ट सदस्य फ़ंक्शन को कॉन्स्ट सदस्य फ़ंक्शन को कॉल करना है और रिटर्न वैल्यू को गैर-कॉन्स्ट संदर्भ में दोबारा डालना है (या यदि सूचक पॉइंटर लौटाता है तो पॉइंटर):

class X 
{ 
    std::vector<Z> vecZ; 

public: 
    const Z& Z(size_t index) const 
    { 
     // same really-really-really long access 
     // and checking code as in OP 
     // ... 
     return vecZ[index]; 
    } 

    Z& Z(size_t index) 
    { 
     // One line. One ugly, ugly line - but just one line! 
     return const_cast<Z&>(static_cast<const X&>(*this).Z(index)); 
    } 

#if 0 // A slightly less-ugly version 
    Z& Z(size_t index) 
    { 
     // Two lines -- one cast. This is slightly less ugly but takes an extra line. 
     const X& constMe = *this; 
     return const_cast<Z&>(constMe.Z(index)); 
    } 
#endif 
}; 

नोट: यह महत्वपूर्ण है कि आप नहीं गैर स्थिरांक समारोह में तर्क डाल करते हैं और स्थिरांक-फ़ंक्शन को कॉल गैर स्थिरांक कार्य हो - यह अपरिभाषित व्यवहार हो सकता है। इसका कारण यह है कि निरंतर वर्ग उदाहरण गैर-निरंतर उदाहरण के रूप में डाला जाता है। गैर-कॉन्स्ट सदस्य फ़ंक्शन गलती से कक्षा को संशोधित कर सकता है, जिसे सी ++ मानक राज्यों के परिणामस्वरूप अपरिभाषित व्यवहार होगा।

Answer 2

This DDJ article टेम्पलेट विशेषज्ञता का उपयोग करके एक तरीका दिखाता है जिसके लिए आपको const_cast का उपयोग करने की आवश्यकता नहीं है। इस तरह के एक साधारण समारोह के लिए हालांकि वास्तव में इसकी आवश्यकता नहीं है।

बूस्ट :: any_cast (एक बिंदु पर, यह अब और नहीं है) नॉन-कॉन्स संस्करण को दोहराने से बचने के लिए कॉन्स्ट संस्करण से एक const_cast का उपयोग करता है। आप गैर-कॉन्स संस्करण पर कॉन्स अर्थशास्त्र लागू नहीं कर सकते हैं, हालांकि आपको बहुत से सावधान रहना होगा।

अंत में कुछ कोड डुप्लिकेशन ठीक है जब तक कि दो स्निपेट सीधे एक दूसरे के शीर्ष पर हों।

Answer 3

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

Answer 4

विस्तृत स्पष्टीकरण के लिए, कृपया "const में डुप्लिकेशन से बचें और गैर-const सदस्य फ़ंक्शन" पर जाएं। 9780321334879.

यहाँ मेयर्स 'समाधान (सरलीकृत):

23, आइटम 3 में प्रभावी सी ++, स्कॉट Meyers, ISBN-13 से 3 डी एड में " const का उपयोग करें जब भी संभव हो,"

struct C { 
    const char & get() const { 
    return c; 
    } 
    char & get() { 
    return const_cast<char &>(static_cast<const C &>(*this).get()); 
    } 
    char c; 
}; 

दो कास्ट और फ़ंक्शन कॉल बदसूरत हो सकती है लेकिन यह सही है। मेयर्स का एक संपूर्ण स्पष्टीकरण क्यों है।

Answer 5

एक मेयर्स की तुलना में अधिक वर्बोज़ सा है, लेकिन मैं यह कर सकता है:

class X { 

    private: 

    // This method MUST NOT be called except from boilerplate accessors. 
    Z &_getZ(size_t index) const { 
     return something; 
    } 

    // boilerplate accessors 
    public: 
    Z &getZ(size_t index)    { return _getZ(index); } 
    const Z &getZ(size_t index) const { return _getZ(index); } 
}; 

कारण है कि यह निजी है निजी विधि अवांछनीय गुण है कि यह एक स्थिरांक उदाहरण के लिए एक गैर स्थिरांक जेड & देता है, जो है । निजी विधियां बाहरी इंटरफ़ेस के इनवेरिएंट को तोड़ सकती हैं (इस मामले में वांछित invariant "एक कॉन्स ऑब्जेक्ट को इसके द्वारा प्राप्त संदर्भों के माध्यम से संशोधित संदर्भों के माध्यम से संशोधित नहीं किया जा सकता है")।

ध्यान दें कि टिप्पणियां पैटर्न का हिस्सा हैं - _getZ का इंटरफ़ेस निर्दिष्ट करता है कि इसे कॉल करने के लिए कभी भी वैध नहीं है (स्पष्ट रूप से एक्सेसर्स से अलग): ऐसा करने के लिए कोई कल्पनीय लाभ नहीं है, क्योंकि यह टाइप करने के लिए 1 और वर्ण है और परिणामस्वरूप छोटे या तेज़ कोड नहीं होंगे। विधि को कॉल करना एक कॉन्स्ट_कास्ट वाले एक्सेसर्स में से किसी एक को कॉल करने के बराबर है, और आप इसे भी नहीं करना चाहेंगे। यदि आप त्रुटियों को स्पष्ट करने के बारे में चिंतित हैं (और यह एक उचित लक्ष्य है), तो _getZ के बजाय इसे const_cast_getZ पर कॉल करें।

वैसे, मैं मेयर्स के समाधान की सराहना करता हूं। मेरे पास इसके लिए कोई दार्शनिक आपत्ति नहीं है। व्यक्तिगत रूप से, हालांकि, मैं नियंत्रित पुनरावृत्ति का एक छोटा सा हिस्सा पसंद करता हूं, और एक निजी विधि जिसे केवल कुछ कसकर नियंत्रित परिस्थितियों में ही जाना चाहिए, जो कि लाइन शोर की तरह दिखता है। अपने जहर उठाओ और इसके साथ छड़ी।

[संपादित करें: केविन ने सही ढंग से इंगित किया है कि _getZ एक और विधि (जेनरजेड कहें) को कॉल करना चाह सकता है जो कि GetZ है। इस मामले में, _getZ एक कॉन्स जेड & देखेंगे और इसे वापस करने से पहले इसे const_cast करना होगा। यह अभी भी सुरक्षित है, क्योंकि बॉयलरप्लेट एक्सेसर सबकुछ दिखाता है, लेकिन यह स्पष्ट रूप से स्पष्ट नहीं है कि यह सुरक्षित है। इसके अलावा, यदि आप ऐसा करते हैं और उसके बाद जेनरजेड को हमेशा कॉन्स लौटने के लिए बदलते हैं, तो आपको हमेशा गेज को वापस करने के लिए getZ को बदलने की आवश्यकता होती है, लेकिन कंपाइलर आपको यह नहीं बताएगा कि आप करते हैं।

संकलक के बारे में बाद का बिंदु मेयर्स के अनुशंसित पैटर्न के बारे में भी सच है, लेकिन एक गैर-स्पष्ट const_cast के बारे में पहला बिंदु नहीं है। तो संतुलन पर मुझे लगता है कि अगर _getZ को इसके वापसी मूल्य के लिए conststcast की आवश्यकता होती है, तो यह पैटर्न मेयर्स के ऊपर अपना बहुत अधिक मूल्य खो देता है। चूंकि मेयर्स की तुलना में यह नुकसान भी पीड़ित है, मुझे लगता है कि मैं उस स्थिति में उसके पास जाऊंगा। एक से दूसरे में रिफैक्टरिंग करना आसान है - यह कक्षा में किसी भी अन्य वैध कोड को प्रभावित नहीं करता है, क्योंकि केवल अमान्य कोड और बॉयलरप्लेट _getZ कॉल करता है।]

Answer 6

तर्क को एक निजी विधि में कैसे ले जाना है, और केवल गेटर्स के अंदर "संदर्भ और वापसी" सामान कर रहे हैं? असल में, मैं स्थिर गठबंधन समारोह के अंदर स्थैतिक और कॉन्स के बारे में काफी उलझन में रहूंगा, और मैं बेहद दुर्लभ परिस्थितियों को छोड़कर बदसूरत मानता हूं!

Answer 7

आप इसे टेम्पलेट्स के साथ भी हल कर सकते हैं। यह समाधान थोड़ा बदसूरत है (लेकिन कुरूपता .cpp फ़ाइल में छिपी हुई है) लेकिन यह स्थिरता की कंपाइलर जांच प्रदान करता है, और कोई कोड डुप्लिकेशन नहीं देता है।

ज फ़ाइल:

#include <vector> 

class Z 
{ 
    // details 
}; 

class X 
{ 
    std::vector<Z> vecZ; 

public: 
    const std::vector<Z>& GetVector() const { return vecZ; } 
    std::vector<Z>& GetVector() { return vecZ; } 

    Z& GetZ(size_t index); 
    const Z& GetZ(size_t index) const; 
}; 

.cpp फ़ाइल:

#include "constnonconst.h" 

template< class ParentPtr, class Child > 
Child& GetZImpl(ParentPtr parent, size_t index) 
{ 
    // ... massive amounts of code ... 

    // Note you may only use methods of X here that are 
    // available in both const and non-const varieties. 

    Child& ret = parent->GetVector()[index]; 

    // ... even more code ... 

    return ret; 
} 

Z& X::GetZ(size_t index) 
{ 
    return GetZImpl< X*, Z >(this, index); 
} 

const Z& X::GetZ(size_t index) const 
{ 
    return GetZImpl< const X*, const Z >(this, index); 
} 

मुख्य नुकसान मैं देख सकता हूँ कि सभी विधि के जटिल कार्यान्वयन एक वैश्विक समारोह में है क्योंकि, आप या तो है उपरोक्त GetVector() जैसे सार्वजनिक विधियों का उपयोग करके एक्स के सदस्यों को पकड़ने की आवश्यकता है (जिनमें से हमेशा एक कॉन्स और गैर-कॉन्स संस्करण होना आवश्यक है) या आप इस फ़ंक्शन को एक दोस्त बना सकते हैं। लेकिन मुझे दोस्तों को पसंद नहीं है।

[संपादित करें: अनावश्यक हटाया परीक्षण के दौरान जोड़ा cstdio के शामिल हैं।]

Answer 8

मुझे लगता है कि स्कॉट Meyers 'समाधान सी ++ 11 एक tempate सहायक फ़ंक्शन का उपयोग करके में सुधार किया जा सकता। इससे इरादा अधिक स्पष्ट हो जाता है और कई अन्य गेटर्स के लिए इसका पुन: उपयोग किया जा सकता है।

template <typename T> 
struct NonConst {typedef T type;}; 
template <typename T> 
struct NonConst<T const> {typedef T type;}; //by value 
template <typename T> 
struct NonConst<T const&> {typedef T& type;}; //by reference 
template <typename T> 
struct NonConst<T const*> {typedef T* type;}; //by pointer 
template <typename T> 
struct NonConst<T const&&> {typedef T&& type;}; //by rvalue-reference 

template<typename TConstReturn, class TObj, typename... TArgs> 
typename NonConst<TConstReturn>::type likeConstVersion(
    TObj const* obj, 
    TConstReturn (TObj::* memFun)(TArgs...) const, 
    TArgs&&... args) { 
     return const_cast<typename NonConst<TConstReturn>::type>(
     (obj->*memFun)(std::forward<TArgs>(args)...)); 
} 

इस सहायक कार्य को निम्न तरीके से उपयोग किया जा सकता है।

struct T { 
    int arr[100]; 

    int const& getElement(size_t i) const{ 
     return arr[i]; 
    } 

    int& getElement(size_t i) { 
     return likeConstVersion(this, &T::getElement, i); 
    } 
}; 

पहला तर्क हमेशा यह सूचक है। दूसरा कॉल करने के लिए सदस्य समारोह के सूचक है। इसके बाद अतिरिक्त तर्कों की मनमानी राशि पारित की जा सकती है ताकि उन्हें कार्य में अग्रेषित किया जा सके। विविधता वाले टेम्पलेट्स के कारण इसे C++ 11 की आवश्यकता है।

Answer 9

अच्छा प्रश्न और अच्छा जवाब।

class X { 

private: 

    std::vector<Z> v; 

    template<typename InstanceType> 
    static auto get(InstanceType& instance, std::size_t i) -> decltype(instance.get(i)) { 
     // massive amounts of code for validating index 
     // the instance variable has to be used to access class members 
     return instance.v[i]; 
    } 

public: 

    const Z& get(std::size_t i) const { 
     return get(*this, i); 
    } 

    Z& get(std::size_t i) { 
     return get(*this, i); 
    } 

}; 

हालांकि, यह एक स्थिर सदस्य और इसके अंदर instance चर का उपयोग कर की जरूरत की आवश्यकता होती है की कुरूपता है: मैं एक और समाधान, कोई डाले का उपयोग करता है।

मैंने इस समाधान के सभी संभावित (नकारात्मक) प्रभावों पर विचार नहीं किया। अगर कोई है तो कृपया मुझे बताएं।

Answer 10

समाधान jwfearn को जोड़ने के लिए, और केविन प्रदान की है, यहां इसी समाधान है जब फ़ंक्शन shared_ptr:

struct C { 
    shared_ptr<const char> get() const { 
    return c; 
    } 
    shared_ptr<char> get() { 
    return const_pointer_cast<char>(static_cast<const C &>(*this).get()); 
    } 
    shared_ptr<char> c; 
}; 

Answer 11

मैं एक दोस्त है जो हक const_cast के उपयोग को सही ठहराया के लिए ऐसा किया ... के बारे में जानते हुए भी नहीं यह मैं शायद कुछ इस तरह (वास्तव में सुरुचिपूर्ण नहीं) किया होता:

#include <iostream> 

class MyClass 
{ 

public: 

    int getI() 
    { 
     std::cout << "non-const getter" << std::endl; 
     return privateGetI<MyClass, int>(*this); 
    } 

    const int getI() const 
    { 
     std::cout << "const getter" << std::endl; 
     return privateGetI<const MyClass, const int>(*this); 
    } 

private: 

    template <class C, typename T> 
    static T privateGetI(C c) 
    { 
     //do my stuff 
     return c._i; 
    } 

    int _i; 
}; 

int main() 
{ 
    const MyClass myConstClass = MyClass(); 
    myConstClass.getI(); 

    MyClass myNonConstClass; 
    myNonConstClass.getI(); 

    return 0; 
} 

Answer 12

मैं एक निजी सहायक स्थिर समारोह टेम्पलेट सुझाव देंगे, इस तरह:

class X 
{ 
    std::vector<Z> vecZ; 

    // ReturnType is explicitly 'Z&' or 'const Z&' 
    // ThisType is deduced to be 'X' or 'const X' 
    template <typename ReturnType, typename ThisType> 
    static ReturnType Z_impl(ThisType& self, size_t index) 
    { 
     // massive amounts of code for validating index 
     ReturnType ret = self.vecZ[index]; 
     // even more code for determining, blah, blah... 
     return ret; 
    } 

public: 
    Z& Z(size_t index) 
    { 
     return Z_impl<Z&>(*this, index); 
    } 
    const Z& Z(size_t index) const 
    { 
     return Z_impl<const Z&>(*this, index); 
    } 
}; 

Answer 13

मैं के लिए क्या देख रहा था वह नहीं मिला, तो मैं अपने ही के एक जोड़े लुढ़का ...

यह एक एक छोटे से अधिक शब्दों वाले है, लेकिन एक ही नाम के कई अतिभारित तरीकों से निपटने का लाभ दिया है (और वापसी प्रकार) सभी को एक बार: आप नाम में केवल एक const विधि, लेकिन अभी भी तरीकों की नकल करने के बहुत सारे है, तो

struct C { 
    int x[10]; 

    int const* getp() const { return x; } 
    int const* getp(int i) const { return &x[i]; } 
    int const* getp(int* p) const { return &x[*p]; } 

    int const& getr() const { return x[0]; } 
    int const& getr(int i) const { return x[i]; } 
    int const& getr(int* p) const { return x[*p]; } 

    template<typename... Ts> 
    auto* getp(Ts... args) { 
    auto const* p = this; 
    return const_cast<int*>(p->getp(args...)); 
    } 

    template<typename... Ts> 
    auto& getr(Ts... args) { 
    auto const* p = this; 
    return const_cast<int&>(p->getr(args...)); 
    } 
}; 

, तो आप इस पसंद कर सकते हैं:

template<typename T, typename... Ts> 
    auto* pwrap(T const* (C::*f)(Ts...) const, Ts... args) { 
    return const_cast<T*>((this->*f)(args...)); 
    } 

    int* getp_i(int i) { return pwrap(&C::getp_i, i); } 
    int* getp_p(int* p) { return pwrap(&C::getp_p, p); } 

दुर्भाग्यवश जैसे ही आप नाम ओवरलोड करना शुरू कर देते हैं (फ़ंक्शन पॉइंटर तर्क की तर्क सूची उस बिंदु पर अनसुलझा प्रतीत होती है, इसलिए इसे फ़ंक्शन तर्क के लिए कोई मिलान नहीं मिल रहा है)। आप भी कि से बाहर अपना रास्ता टेम्पलेट हालांकि कर सकते हैं:

template<typename... Ts> 
    auto* getp(Ts... args) { return pwrap<int, Ts...>(&C::getp, args...); } 

लेकिन const विधि के संदर्भ में तर्क टेम्पलेट के लिए जाहिरा तौर पर दर-मूल्य तर्कों के खिलाफ मैच के लिए असफल और यह टूट जाता है। यकीन नहीं क्यों।Here's why।

Answer 14

क्या यह प्रीप्रोसेसर का उपयोग करने के लिए धोखा दे रहा है?

struct A { 

    #define GETTER_CORE_CODE  \ 
    /* line 1 of getter code */ \ 
    /* line 2 of getter code */ \ 
    /* .....etc............. */ \ 
    /* line n of getter code */  

    //^NOTE: line continuation char '\' on all lines but the last 

    B& get() { 
     GETTER_CORE_CODE 
    } 

    const B& get() const { 
     GETTER_CORE_CODE 
    } 

    #undef GETTER_CORE_CODE 

}; 

यह टेम्पलेट्स या डाले के रूप में के रूप में पसंद नहीं है, लेकिन यह अपने इरादे पड़ता है ("इन दोनों कार्यों समान हो रहे हैं") बहुत स्पष्ट।

Answer 15

सी ++ 17 इस प्रश्न के लिए सर्वश्रेष्ठ उत्तर को अपडेट किया गया:

T const & f() const { 
    return something_complicated(); 
} 
T & f() { 
    return const_cast<T &>(std::as_const(*this).f()); 
} 

यह फायदे है कि यह:

• स्पष्ट है क्या
• पर जा रहा है कम से कम कोड भूमि के ऊपर है - यह एक पंक्ति में फिट बैठता है
• गलत होना मुश्किल है (केवल volatile को दुर्घटना से दूर कर सकता है, लेकिन volatile एक दुर्लभ क्वालीफ है ier)