Question

Code in c++ please. 
Does not have to be complete, just write code for the ones you know.
Thank you.

template <typename T>
class smart_ptr {
public:
    smart_ptr();
      // Create a smart_ptr that is initialized to nullptr. The reference count
      // should be initialized to nullptr.
      
    explicit smart_ptr(T* raw_ptr);
      // Create a smart_ptr that is initialized to raw_ptr. The reference count
      // should be one.         

    smart_ptr(const smart_ptr& rhs);
      // Copy construct a pointer from rhs. The reference count should be 
      // incremented by one.

    smart_ptr(smart_ptr&& rhs);
      // Move construct a pointer from rhs.

    smart_ptr& operator=(const smart_ptr& rhs);
      // This assignment should make a shallow copy of the right-hand side's
      // pointer data. The reference count should be incremented as appropriate.

    smart_ptr& operator=(smart_ptr&& rhs);
      // This move assignment should steal the right-hand side's pointer data.
      
    bool clone();
      // If the smart_ptr is either nullptr or has a reference count of one, this
      // function will do nothing and return false. Otherwise, the referred to
      // object's reference count will be decreased and a new deep copy of the
      // object will be created. This new copy will be the object that this
      // smart_ptr points and its reference count will be one. 
      
    int ref_count() const;
      // Returns the reference count of the pointed to data.

    T& operator*();
      // The dereference operator shall return a reference to the referred object.
      // Throws null_ptr_exception on invalid access. 

    T* operator->();
      // The arrow operator shall return the pointer ptr_. Throws null_ptr_exception
      // on invalid access.

    ~smart_ptr();          // deallocate all dynamic memory
    
private:
    T* ptr_;               // pointer to the referred object
    int* ref_;             // pointer to a reference count
};

Answer 1

Here is my C++ Code:

template <typename T>
class smart_ptr {
public:
    smart_ptr();
      // Create a smart_ptr that is initialized to nullptr. The reference count
      // should be initialized to nullptr.

    explicit smart_ptr(T* raw_ptr);
      // Create a smart_ptr that is initialized to raw_ptr. The reference count
      // should be one.

    smart_ptr(const smart_ptr& rhs);
      // Copy construct a pointer from rhs. The reference count should be
      // incremented by one.

    smart_ptr(smart_ptr&& rhs);
      // Move construct a pointer from rhs.

    smart_ptr& operator=(const smart_ptr& rhs);
      // This assignment should make a shallow copy of the right-hand side's
      // pointer data. The reference count should be incremented as appropriate.

    smart_ptr& operator=(smart_ptr&& rhs);
      // This move assignment should steal the right-hand side's pointer data.

    bool clone();
      // If the smart_ptr is either nullptr or has a reference count of one, this
      // function will do nothing and return false. Otherwise, the referred to
      // object's reference count will be decreased and a new deep copy of the
      // object will be created. This new copy will be the object that this
      // smart_ptr points and its reference count will be one.

    int ref_count() const;
      // Returns the reference count of the pointed to data.

    T& operator*();
      // The dereference operator shall return a reference to the referred object.
      // Throws null_ptr_exception on invalid access.

    T* operator->();
      // The arrow operator shall return the pointer ptr_. Throws null_ptr_exception
      // on invalid access.

    ~smart_ptr();          // deallocate all dynamic memory

private:
    T* ptr_;               // pointer to the referred object
    int* ref_;             // pointer to a reference count
};

template<typename T> smart_ptr<T>::smart_ptr(){
    ptr_ = nullptr;
    ref_ = nullptr;
}

template<typename T> smart_ptr<T>::smart_ptr(T* row_ptr){
    ptr_ = row_ptr;
    if(ref_ == nullptr){
        ref_ = new int(1);
    }
}

template<typename T> smart_ptr<T>::smart_ptr(const smart_ptr& rhs){
    ptr_ = rhs->ptr_;
    *ref_++;
}

template<typename T> smart_ptr<T>::smart_ptr(smart_ptr&& rhs){
    ptr_ = rhs->ptr_;
    *ref_++;
    rhs.ref_ = nullptr;
    rhs.ptr_ = nullptr;
}

template<typename T> smart_ptr<T>& smart_ptr<T>::operator=(const smart_ptr& rhs){
    ptr_ = rhs->ptr_;
    *ref_++;
    return *this;
}

template<typename T> smart_ptr<T>& smart_ptr<T>::operator=(smart_ptr&& rhs){
    ptr_ = rhs->ptr_;
    *ref_++;
    rhs.ref_ = nullptr;
    rhs.ptr_ = nullptr;
    return *this;
}

template<typename T> bool smart_ptr<T>::clone(){
    if(ptr_ == nullptr || *ref_ == 1)
        return false;
    else{
        *ref_--;
        smart_ptr<T> deepcopy = new smart_ptr<T>(*this);
        *(deepcopy.ref_) = 1;
        return true;
    }
}

template<typename T> int smart_ptr<T>::ref_count() const{
    return *ref_;
}

template<typename T> T& smart_ptr<T>::operator*(){
    return *ptr_;
}

template<typename T> T* smart_ptr<T>::operator->(){
    return ptr_;
}

template<typename T> smart_ptr<T>::~smart_ptr(){
    delete ptr_;
    delete ref_;
}

int main(){
    return 0;
}

if you have any query then feel free to ask in comment.