Refactoring c++ template class based on template type -

दिए गए वर्ग फू

  टेम्पलेट & lt; typename T & gt; वर्ग फ़ू {सार्वजनिक: ... अन्य विधियों .. शून्य बार () {... m_impl.doSomething (); ...} शून्य मज़ा () {... m_impl.doSomethingElse (); ...} शून्य fubar () {...} निजी: टी m_impl; };   
 मैं ऐसे परिस्थितियों को पूरा करना चाहता था जहां टी को बढ़ावा दिया गया है: shared_ptr इस मामले में क्लास फ़ू में केवल बदलाव यह है कि इसे  
  m_impl-> doSomething ();   
 के बजाय  
  m_impl.doSomething ();   
 मैंने एक ही शीर्ष लेख में FooPtr को परिभाषित किया  
  टेम्पलेट & lt; typename T & gt; वर्ग FooPtr {सार्वजनिक: ... अन्य विधियों .. शून्य बार () {... m_pImpl- & gt; doSomething (); ...} शून्य मज़ा () {... m_pImpl- & gt; doSomethingElse (); ...} शून्य fubar () {...} निजी: बढ़ावा :: share_ptr & lt; T & gt; m_pImpl; };   
 अब जब दृष्टिकोण सभी वर्गों के लिए काम करता है, जो मैं फ़ू के साथ उपयोग करना चाहता हूं, तो समस्या यह है कि मेरे पास कई डुप्लिकेट कोड हैं जो कि चारों ओर झूठ बोलते हैं और मैं जो भी परिवर्तन करता हूं I FooPtr को करना पड़ता है।  
 मैं कोड को कैसे रिफैक्टर कर सकता हूं? जैसे क्या कोई तरीका है जो मैं संकलन समय पर निर्धारित कर सकता हूं यदि टी प्रकार की boost :: shared_ptr है, और उसके बाद केवल बार और मजेदार तरीकों के विशेषज्ञ - - gt; ऑपरेटर?  
 संपादित करें: अब तक सभी उत्तर के लिए धन्यवाद! मुझे सिर्फ उन सभी के माध्यम से काम करने के लिए कुछ समय चाहिए और देखें कि हमारे सॉफ़्टवेयर के लिए कौन सा समाधान सबसे अच्छी बात है।  
 संपादित करें 2: @ मैथियू: यह परीक्षण कोड है जिसका उपयोग मैं कर रहा था  
  वर्ग FooImpl {सार्वजनिक: शून्य doIt () {cout & lt; & lt; "ए" & lt; & lt; std :: endl; }}; Int _tmain (int argc, _TCHAR * argv []) {Foo & lt; FooImpl & gt; foo; foo.doSomething (); वापसी 0; }    
 
 
 सिल्वैन ने एक हलके समाधान लिखा है, लेकिन मुझे दुर्व्यवहार विरासत पसंद नहीं है। / P> 
 अंतरफलक को एकरूप बनाने के लिए आवरण वर्ग का प्रयोग करना आसान है, खासकर जब सूचक सीमेंटिक्स इतनी अच्छी तरह से काम करता है!  
  नाम स्थान विवरण {टेम्पलेट & lt; typename T & gt; स्ट्रक्चर फूडेड्यूसर {typedef बढ़ावा :: वैकल्पिक & lt; T & gt; प्रकार; }; टेम्पलेट & lt; typename T & gt; संरचना फूडेड्यूसर & lt; T * & gt; {टाइप कियाइफ़ टी * प्रकार; }; टेम्पलेट & lt; typename T & gt; संरचना फूडेड्यूसर & lt; को बढ़ावा देने :: shared_ptr & LT; टी & gt; & Gt; {टाइप-टोफ़ बढ़ावा :: साझा_पीटीआर & lt; T & gt; प्रकार; }; } // नाम स्थान विवरण टेम्पलेट & lt; typename T & gt; वर्ग फू {सार्वजनिक: // methods void doSomething () {impl- & gt; doIt (); } निजी: टाइप किया गया टाइपअनाम विवरण :: FooDeducer & lt; T & gt; :: प्रकार प्रकार; टाइप करें; };   
 यहां,  बढ़ावा :: वैकल्पिक  पर निर्भर, जो वैकल्पिक पाइन्टेई शब्दों को प्रदान करता है, हम लगभग पॉइंटर्स के समान व्यवहार प्राप्त करते हैं।  
 एक बिंदु मैं हालांकि जोर देना चाहता हूं, नकल व्यवहार में अंतर है  बढ़ावा :: वैकल्पिक  गहरी कॉपी प्रदान करता है।