टेम्पलेट नौसिखिया यहाँ। मैं निम्नलिखित टेस्ट क्लास के साथ खेल रहा हूं:

template<typename T>
class Container
{
public:

    Container(T t) : m_t(t) {}

    T clone()
    {
        return m_t;
    }

private:

    T m_t;
};

clone() विधि सदस्य चर की एक प्रति लौटाती है। जाहिर है, यह इरादा के अनुसार काम नहीं करता है यदि टी एक सूचक है, उदाहरण:

Container<SomeClass*> container(new SomeClass());

clone() विधि केवल एक पॉइंटर लौटाएगी, न कि पूर्ण क्लोन। मैं if constexpr की सुंदरता से वाकिफ हूं लेकिन दुर्भाग्य से मैं C++14 कंपाइलर के साथ फंस गया हूं। मैं अपनी कक्षा को सामान्य रखना चाहता हूं ताकि यह पॉइंटर्स के साथ भी काम करे। क्या मुझे दो अलग-अलग तरीके बनाने चाहिए? क्या यहां SFINAE कोई मदद कर सकता है?

0
Ignorant 28 जुलाई 2019, 13:45

2 जवाब

सबसे बढ़िया उत्तर

पूरी कक्षा को विशेषज्ञ बनाने के लिए, जैसा कि दूसरे उत्तर से पता चलता है, आपको बहुत सारे कोड की नकल करने की आवश्यकता हो सकती है (अच्छी बात नहीं)।

इसके बजाय, मेरा सुझाव है कि अच्छा ol' टैग प्रेषण:

template<typename T>
class Container
{
    T clone_low(std::false_type)
    {
        return m_t;
    }

    T clone_low(std::true_type)
    {
        return new std::remove_pointer_t<T>(m_t);
    }

  public:
    Container(T t) : m_t(t) {}

    T clone()
    {
        return clone_low(std::is_pointer<T>{});
    }

  private:
    T m_t;
};
5
HolyBlackCat 28 जुलाई 2019, 15:00

आप कक्षा की आंशिक विशेषज्ञता का उपयोग कर सकते हैं। उदाहरण के लिए

#include <iostream>

template<typename T>
class Container
{
public:
    Container(T t) : m_t(t) {}
    T clone()
    {
        return m_t;
    }

private:

    T m_t;
};

template<typename T>
class Container<T*>
{
public:
    Container(T* t) : m_t(new T(*t)) {}
    T* clone()
    {
        return new T(*m_t);
    }
    ~Container() { delete m_t; }

private:
    T* m_t;
};

int main()
{
    std::cout << Container<int>(10).clone() << '\n';

    int x = 20;
    Container<int*> c(&x);

    int* p = c.clone();
    std::cout << *p << '\n';

    delete p;
    return 0;
}
4
MyClass 28 जुलाई 2019, 22:22