Manually write smart pointer shared_ PTR function

Environmental Science CLion + MinGW

// Manually override the smart pointer 
#include "CustomPtr.h"

class Student {
    
public:
    ~Student() {
    
        cout << " Destructor   Release Student" << endl;
    }
};
// TODO  Built in smart pointer 
void action() {
    
    Student *student1 = new Student();
    Student *student2 = new Student();

    // TODO  Case one 
// shared_ptr<Student> sharedPtr1(student1);
// shared_ptr<Student> sharedPtr2(student2);

    // TODO  The second case 
    shared_ptr<Student> sharedPtr1 (student1);
    shared_ptr<Student> sharedPtr2 = sharedPtr1;

    // TODO  Print 
    cout << " Built in smart pointer  sharedPtr1:" << sharedPtr1.use_count() << endl;
    cout << " Built in smart pointer  sharedPtr2:" << sharedPtr2.use_count() << endl;
}


void action2() {
    
    Student *student1 = new Student();
    Student *student2 = new Student();

    // TODO  Case one 
// Ptr<Student> sharedPtr1(student1);
// Ptr<Student> sharedPtr2(student2);

    // TODO  The second case   copy constructor 
// Ptr<Student> sharedPtr1 (student1);
// Ptr<Student> sharedPtr2 = sharedPtr1;

    // TODO  The second case 
    // TODO  Situation 1 
// Ptr<Student> sharedPtr1 (student1); //  Call the copy constructor of the handwritten smart pointer 
// Ptr<Student> sharedPtr2;
// sharedPtr2 = sharedPtr1;


    // TODO  Situation two 
    Ptr<Student> sharedPtr1 (student1); // Call the of handwriting smart pointer = Operator overload function 
    Ptr<Student> sharedPtr2 (student2);
    sharedPtr2 = sharedPtr1;

    // TODO  Print 
    cout << " Handwritten smart pointer  sharedPtr1:" << sharedPtr1.use_count() << endl;
    cout << " Handwritten smart pointer  sharedPtr2:" << sharedPtr2.use_count() << endl;
}

int main(){
    
// cout << " Here is  C++ Built in smart pointer  ===========" << endl;
// action();
// cout << endl;

    cout << " Here is   Custom smart pointer  ===========" << endl;
    action2();


    return 0;
}

#ifndef TEST_CLION_CUSTOMPTR_H
#define TEST_CLION_CUSTOMPTR_H

#pragma once

#include <iostream>
#include <memory> //  Smart pointer 

using namespace std;

template<typename T>
class Ptr {
    
private:
    T *object;
    int *count;
public:
    Ptr() {
     // Null parameter constructor , When new  Execute when an empty object 
        count = new int(1);
        object = 0;
    }

    Ptr(T *t) : object(t) {
    // When new With a T Execute when the parameter object of 
        count = new int(1);
    };

    ~Ptr() {
    
        if (--(*count) == 0) {
    
            if (object) {
    
                delete object;
            }
            //  Zeroing 
            delete count;
            object = 0;
            count = 0;
        }
    }

    Ptr(const Ptr<T> &p) {
    
        cout << " copy constructor " << endl;

        ++(*p.count);

        object = p.object;  // When executed, the left side is through this Get a new object   On the right is the old object coming in 
        count = p.count;
    }

    Ptr<T> &operator=(const Ptr<T> &p) {
    
        cout << "= Operator overload " << endl;

        ++(*p.count);

        if (--(*count) == 0) {
     // scene ：  object 2 =  object 1  operation ： Object first 2 To analyze   At present, the object is cleared 2 All members point to , And then assign the value 
            if (object) {
          // Otherwise, the object 2  The assignment object belongs to the field before assignment 
                delete object;
            }
            delete count;
        }

        object = p.object;  // When executing, the left side is the object 2（this  Point to ）  On the right is the incoming object 1
        count = p.count;
        return *this; //  Operator overloaded return 
    }
    // Returns the number of references to the object 
    int use_count() {
    
        return *this->count;
    }
};


#endif //TEST_CLION_CUSTOMPTR_H