Задачи для тренировки и лучшего понимания

std::auto_ptr<int>    one   (new int);
std::auto_ptr<double> second(new double);
 
f(one, second);

template <typename T> 
class Some_class
{
public:
   Some_class(T _arg = T());
   Some_class& operator =(Some_class const & other);
 
   void swap(Some_class & other) throw();
private:
   T arg;
};
 
template <typename T>
Some_class<T>::Some_class(T _arg)
    {
    arg = _arg;
    }
 
template <typename T>
void Some_class<T>::swap(Some_class<T> & other) throw()
    {
    T temp = other.arg;
    other.arg = this->arg;
    this->arg = temp;
    }
 
template <typename T>
Some_class<T> & Some_class<T>::operator=(Some_class const & other)
    {
    Some_class<T> temp(other);
 
    swap(temp);
 
    return *this;
    }
 
int main()
    {
    Some_class<int> A(10),B;
    B = A;
    }

template <typename T> 
class Some_class
    {
    public:
        Some_class();
        Some_class(Some_class<T> const & other);
        Some_class& operator =(Some_class const & other);
 
        void swap(Some_class & other) throw();
    private:
        std::auto_ptr<T> arg;
    };
 
template <typename T>
Some_class<T>::Some_class()
    : arg(new T())
    {
    }
 
template <typename T>
Some_class<T>::Some_class(Some_class<T> const & other)
    : arg(new T(*other.arg))
    {
    }
 
template <typename T>
void Some_class<T>::swap(Some_class<T> & other) throw()
    {
    std::auto_ptr<T> temp(arg);
    arg = other.arg;
    other.arg = temp;
    }
 
template <typename T>
Some_class<T> & Some_class<T>::operator=(Some_class const & other)
    {
    Some_class<T> temp(other);
 
    swap(temp);
 
    return *this;
    }

template<class T>
class SomeClass
{
public:
    SomeClass(T arg=0):impl_(new SomeClassImpl(arg))
    {
    }
    ~SomeClass()
    {
    }
    SomeClass(const SomeClass& other):impl_(new T(*other.impl_))
    {
    }
    SomeClass& operator =(const SomeClass& other)
    {
        SomeClass tmp(other);
        Swap(tmp);
        return *this;
    }
private:
    class SomeClassImpl;
    std::auto_ptr<SomeClassImpl> impl_;
    void Swap(SomeClass& other)
    {
        std::auto_ptr<SomeClassImpl> tmp(impl_);
        impl_=other.impl_;
        other.impl_=tmp;
    }
};
 
template<class T>
class SomeClass<T>::SomeClassImpl
{
public:
    SomeClassImpl(T arg_=0):arg(arg_)
    {
    }
    ~SomeClassImpl()
    {
    }
    SomeClassImpl(const SomeClassImpl& other):arg(other.arg)
    {
    }
    SomeClassImpl& operator =(const SomeClassImpl& other)
    {
        SomeClassImpl tmp(other);
        Swap(tmp);
        return *this;
    }
private:
    T arg;
    void Swap(SomeClassImpl& other)
    {
        std::swap(arg, other.arg);
    }
};