clone_ptr问题，我需要使用库的函数而不是新的来创建一个复制对象 [英] clone_ptr problem, I need to create a copy object using a function of the library instead of new

问题描述

我对C ++中的模板有点新，所以原谅我如果这个问题是混乱或愚蠢的，我只是有一个问题，我想实现一个克隆智能指针，所以我不必为每个创建复制构造函数，每个使用我的底层XML库的类，只是似乎使用对象指针，而不是智能指针。问题是，我的traits需要使用基础库中的函数创建新对象，我不知道我将如何在模板/ traits类中这样做。我已经张贴了所有的代码，下面有一些意见，如果有人可以建议，我会很感激。

I am a bit new to templates in C++ so forgive me if this question is confusing or stupid, I just have a problem where I want to implement a clone smart pointer so I don't have to create copy constructors for each and every class that uses my underlying XML library that only seems to use object pointers and not smart pointers. The problem is that my traits need to create the new objects using functions from the underlying library and I do not know how I would go about doing that in a template/traits class. I have posted all the code with some comments below, if anybody could advice, I'd appreciate it.

如果有什么不清楚，请问，我会尽力澄清。

If something is unclear, please ask and I will try to clarify.

#ifndef CLONE_PTR_H
#define CLONE_PTR_H

#include <algorithm>
#include <functional>
#include <xercesc/dom/DOM.hpp>
#include <xercesc/dom/DOMDocument.hpp>

struct DOMObject_cloner
{
    static DOMDocument* clone(DOMDocument* pPtr)
    {
        DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(X("Core"));  // this looks wrong, depends on DOMIMplementation_cloner being done really... how do I do this properly
        return pPtr ?  : impl->createDocument(...) //I need this function for a DOMDocument* to be created!!!
    }
};

struct DOMImplementation_cloner
{
    static DOMImplementation* clone(DOMImplementation* pPtr)
    {
        return pPtr ? DOMImplementationRegistry::getDOMImplementation(X("Core")) : 0;
    }
};

template<typename T>
struct default_clone
{
    static T* clone(T* pPtr)
    {
        return pPtr ? pPtr->clone() : 0;
    }
};


template <typename T, typename Cloner = default_clone<T> >
    class clone_ptr
    {
    public:
        // types
        typedef T element_type;

        typedef element_type value_type;
        typedef const element_type const_value_type;
        typedef value_type* pointer;
        typedef const_value_type* const_pointer;
        typedef value_type& reference;
        typedef const_value_type& const_reference;

        // creation
        clone_ptr() :
        mPtr(0)
        {}

        explicit clone_ptr(pointer pPtr) :
        mPtr(pPtr)
        {}


        clone_ptr(const clone_ptr& pOther) :
        mPtr(pOther.get() ? Cloner()(pOther.get()) : 0)
        {}

      /*clone_ptr(const clone_ptr& pOther) :
        mPtr(pOther.get() ? pOther->clone() : 0),
        {}*/


        clone_ptr& operator=(clone_ptr pOther)
        {
            swap(*this, pOther);

            return *this;
        }

        ~clone_ptr()
        {
            delete get();
        }

        // observers
        pointer get() const
        {
            return mPtr;
        }

        pointer operator->() const
        {
            return get();
        }

        reference operator*() const
        {
            assert(get() != 0);
            return *get();
        }

        // modifiers
        pointer release()
        {
            pointer result = mPtr;
            mPtr = 0;

            return result;
        }

        void reset(pointer pPtr = 0)
        {
            *this = clone_ptr(pPtr);
        }

        // utility
        friend void swap(clone_ptr& pFirst, clone_ptr& pSecond)
        {
            std::swap(pFirst.mPtr, pSecond.mPtr);
        }

    private:
        pointer mPtr;
        //default_clone Cloner;
    };

    template <typename T1>
    bool operator!(const clone_ptr<T1>& pX)
    {
        return pX.get() == 0;
    };

    template <typename T1, typename T2>
    bool operator>=(const clone_ptr<T1>& pFirst, const clone_ptr<T2>& pSecond)
    {
        return !(pFirst < pSecond);
    };

    // compare
    template <typename T1, typename T2>
    bool operator==(const clone_ptr<T1>& pFirst, const clone_ptr<T2>& pSecond)
    {
        return pFirst.get() == pSecond.get();
    };

    template <typename T1, typename T2>
    bool operator!=(const clone_ptr<T1>& pFirst, const clone_ptr<T2>& pSecond)
    {
        return !(pFirst == pSecond);
    };

    template <typename T1, typename T2>
    bool operator<(const clone_ptr<T1>& pFirst, const clone_ptr<T2>& pSecond)
    {
        return std::less<void*>()(pFirst.get(), pSecond.get());
    };

    template <typename T1, typename T2>
    bool operator<=(const clone_ptr<T1>& pFirst, const clone_ptr<T2>& pSecond)
    {
        return !(pFirst > pSecond);
    };

    template <typename T1, typename T2>
    bool operator>(const clone_ptr<T1>& pFirst, const clone_ptr<T2>& pSecond)
    {
        return pSecond < pFirst;
    };

#endif

推荐答案

I我真的不知道如果我理解你的问题，但我看到一件事，你的代码。 DOMObject_cloner 和 DOMImplementation_cloner 应该是 default_clone ：

I am not really sure if I understand your question, but I see one thing wrong with your code. DOMObject_cloner and DOMImplementation_cloner should be specializations of default_clone, like this:

template<>
struct default_clone<DOMDocument> {
    static DOMDocument* clone(DOMDocument* pPtr)
    {
        DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(X("Core"));
        return pPtr ?  : impl->createDocument(...);
    }
};

模板专业化是C ++中的全部特性。

Template specialization is the whole point of traits in C++.

这篇关于clone_ptr问题，我需要使用库的函数而不是新的来创建一个复制对象的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！