#pragma once
#ifndef _AUTOPTR
#define _AUTOPTR

//#include "smartPointer.hpp"
//think passing smart pointer to auto pointer 
//would cause segfault if we delete autopointer
//but reverse is safe

template <typename T>
class autoPtr{
    T* _pointee;
public:
    autoPtr();
    explicit autoPtr(T * pointee);
    autoPtr(const autoPtr<T> &sp);
    autoPtr(autoPtr<T> &sp);
    ~autoPtr();
    autoPtr<T>& operator=(autoPtr<T>& sp);
    operator bool()const;
    T& operator*()const;
    T* operator->()const;
};

template <typename T>
autoPtr<T>::autoPtr()
{
    _pointee = 0;
}

template <typename T>
autoPtr<T>::autoPtr(T * pointee)
{
    _pointee = pointee;
}

template <typename T>
autoPtr<T>::autoPtr(const autoPtr<T> &sp)
{
}

template <typename T>
autoPtr<T>::autoPtr(autoPtr<T> &sp)
{
    _pointee = sp._pointee;
    sp._pointee = 0;
}

template <typename T>
autoPtr<T>::~autoPtr()
{
    delete _pointee;
}

template <typename T>
autoPtr<T>& autoPtr<T>::operator=(autoPtr<T>& sp)
{
    if(this != &sp)
    {
        if(_pointee)
            delete _pointee;
        _pointee = sp._pointee;
        sp._pointee=0;
    }
    return *this;
}

template <typename T>
autoPtr<T>::operator bool()const
{
    return _pointee!=0;
}

template <typename T>
T& autoPtr<T>::operator*()const
{
    return *_pointee;
}

template <typename T>
T* autoPtr<T>::operator->()const
{
    return _pointee;
}


#endif