Code Review

Don't see the point in this member:

    T** ptrToPtr;

    rCPtr()
    {
        try
        {
            ptr = new T;

Calling new to create a new T is not appropriate here (having an empty object is perfectly fine). As the user may turn around and set a new pointer to own. As a result you don't need a try/catch block on this one.

I don't mind the way you use try/catch here but it is worth pointing out the try/catch for constructors can be written to include the initializer list.

   rCPtr()
      : ptr(nullptr)
      , refCount(nullptr)
   {}
    

Yes you do need the try block on this constructor (because you have guaranteed that the object will be managed and thus destroyed). Note this destruction is not just about calling delete and memory management but also about doing the correct resource management.

    explicit rCPtr(T* pT)
    {
        try
        {
            ptr = pT;
            ptrToPtr = &ptr;
            refCount = new long;  // Why not allocate and initialize
            *refCount = 1;        // in one statement?
        }
        catch(...)
        {
            if (ptr)          // Don't need to check for null before
                delete ptr;   // calling delete.

            if (refCount)        // If the new long throws this is in
                delete refCount; // an indeterminate state. So calling
                                 // delete here is actually UB.

            // If there is an exception you need to make sure that
            // it continues.
            // otherwise your object contains invalid data by
            // making the exception continue you are saying that the
            // construction failed and the object is not valid.

            throw; // re-throws the current exception.
        }
    }

Though this try/catch is fine, I like the special version of try/catch for constructors as it allows you put the try/catch around the initializer list.

    explicit rCPtr(T* pT)
    try
        : ptr(pT)
        , ptrToPtr(&ptr)
        , refCount(new long(1))
    {}
    catch(...)
    {
        delete ptr;
        // don't need to call delete on refCount.
        // this is the only thing that could have failed and thrown
        // so the value is in an indeterminate state anyway,

        // Note: rethrow is not needed here.
    }

I have an issue with checking if refCount is "smaller" or equal to zero. If your refCount has gone below zero when you don't expect it to then you have some serious bug in your application (you have probably already called delete on a non-null pointer and thus this is likely to be a second call to delete on the pointer and you have just entered UB territory).

If your ref count does something unexpected the only thing you can do is exit the application and hope that nothing serious has been destroyed by the data.

    ~rCPtr()
    {
        (*refCount)--;


        // If refCount is smaller than z
        if (*refCount <= 0)
        {
            delete ptr;
            ptr = nullptr;         // nulling out ptr is a waste of time.
                                   // It also hides errors. The debug
                                   // standard libraries have extra code for
                                   // doing memory validation.
                                   //
                                   // If you have a bug and don't reset the
                                   // ptr to null then the debug libraries
                                   // may be able to help you detect it.
                                   //
                                   //
            // There is a small possibility that the previous delete throws.
            // you still want to make sure that the next delete works
            // even if the previous one throws.
            delete refCount;
            refCount = nullptr;
        }
    }

You only set two of your three member variables. Make sure constructors always initialize all members.

    rCPtr(const rCPtr& other) : ptr(other.ptr), refCount(other.refCount)
    {
        (*refCount)++;
    }

Note: They are the same if they both use the same refCount object.

    // If you pass another of same object.
    rCPtr& operator=(const rCPtr &right)
    {

       // I would check if refCount == right.refCount
       // If they are the same then you are not going to change.
       if (this == &right) {return *this;}


       T* leftPtr = ptr;
       long* leftCount = refCount;

       ptr = right.ptr;
       refCount = right.refCount;


        (*refCount)++;
        (*leftCount)--;

        // delete if no more references to the left pointer.
        if (*leftCount <= 0)
        {
            delete leftPtr;
            leftPtr = nullptr;

            // Again there is a small chance that the above delete will throw.
            // You need to make sure that this second delete is called even
            // if that happens.
            delete leftCount;
            leftCount = nullptr;
        }
        return *this;
    }

Personally I would still use the copy-and-swap idiom to implement this functionality. It is a tried and tested technique to give you the strong exception guarantee.

    rCPtr& operator=(const rCPtr &right)
    {
        rCPtr  copy(right);
        swap(copy);
        return *this;

        // This way the destructor handles all the deallocation and ref
        // counting, and you keep that all in the same space.
        //
        // Note: Here it is the destructor of `copy` that will make sure
        //       the object ref counts are all kept correctly aligned.
    }

    rCPtr& operator=(const T* right)
    {
        // If you assign a pointer that is already being managed.
        // That is a major bug in your user's code.
        // Not sure ignoring it is the correct solution.
        //
        // Not sure what the best answer is either.
        if (right == ptr) {return *this;}

        T* leftPtr = ptr;
        long* leftCount = refCount;

        ptr = right;

        // THIS IS A BUG.
        // This refCount is still pointing at the refCount
        // object for the original value. This value may be
        // shared with several other smart pointers so you can
        // not reuse it. You should allocate a new one.
        //
        // If you have several objects that were using the refCount
        // object they all now have a refCount of 1 which may result
        // in your counter going below zero.
        *refCount = 1; // New refCount will always be 1

        // Note: leftCount and refCount still both point at the
        //       same object. This means the counter just reached
        //       zero. So the next section is going to deallocate it.
        (*leftCount)--; 

        if (*leftCount <= 0)
        {
            delete leftPtr;
            leftPtr = nullptr;

            // Same issue with the delete as before.
            // This sort of emphasizes that common code should be
            // written once and in its own function. That way if you
            // find a bug you only have to fix it in one place and
            // that remoes the human errror of fixes that same bug
            // in multiple pleaces.
            delete leftCount;
            leftCount = nullptr;
        }

    }

In the standard version of smart pointers, calling * or -> is UB if the contained pointer is null. It is the responsibility of the caller to make sure that the smart pointer is holding an appropriate value.

    T* operator->() const
    {
        if (exists())
        return *ptrToPtr;       // Indentation issue.
        else return nullptr;

    }    

    T& operator*() const
    {

        if (exists())
        return **ptrToPtr;       // Indentation issue.

            throw std::out_of_range("Pointer is already deleted");
    }

Note dynamic_cast<> when applied to pointers does not throw (it will return a null pointer on failure).

    // Will attempt to cast the stored pointer into a new type & return it
    // You probably should not delete this one either
    template <class X>
    X* dCast()
    {
        try
        {
            // X must be polymorphic, or else the cast will fail and cause a compiler error.
            auto casted = dynamic_cast<X*>(*ptrToPtr);
            return casted;
        }catch(const std::bad_cast& me)
        {
            return nullptr;
        }


    }

I wrote a couple of articles on this stuff:

Unique Ptr
Shared Ptr
Specialized constructors

How I would write it:

#include <stdexcept>

//Try to create a smart pointer? Should be fun.


template <class T>
class rCPtr
{
    template<typename U>
    class DeletePtrUtility
    {
        U* ptr;
        public:
            DeletePtrUtility(U* p) : ptr(p){}
            ~DeletePtrUtility()            {delete ptr;}
    };

    T*    ptr;
    long* refCount;

    public:

    rCPtr()
        : ptr(nullptr)
        , refCount(nullptr)
    {}

    explicit rCPtr(T* pT)
    try
        : ptr(pT)
        // Only allocate a refCount if the pointer is not null
        // this matches the default constructor action.
        , refCount(pT ? new long(1) : nullptr)
    {}
    catch(...)
    {
        delete pT;
    }

    ~rCPtr()
    {
        // This is the only place where delete happens.
        // So make sure it is correct. All other operations
        // that can result in a delete will do this be invoking
        // the destructor (using copy and swap).

        if (refCount)
        {
            // If the pointer stored is null then the refCount
            // is also null so we can't de-reference it.
            --(*refCount);
            if (*refCount == 0)
            {
                // Make sure delete is always called on both
                // pointers (even if there is an exception).
                DeletePtrUtility<T>     deleteDataPtr(ptr);
                DeletePtrUtility<long>  deleteRefCPtr(refCount);
            }
        }
    }

    void swap(rCPtr& other)
    {
        std::swap(ptr,      other.ptr);
        std::swap(refCount, other.refCount);
    }
    friend void swap(rCPtr& lhs, rCPtr& rhs)
    {
        lhs.swap(rhs);
    }

    rCPtr(const rCPtr& other)
        : ptr(other.ptr)
        , refCount(other.refCount)
    {
        if (refCount) {
            // If there is an object, increment refcount.
            ++(*refCount);
        }
    }

    rCPtr& operator=(const rCPtr &right)
    {
        // Use copy and swap idiom
        rCPtr   copy(right);   // the minimum required to create object.
        swap(copy);            // Swap current and new state.
        return *this;
        // The destructor on copy will do the correct thing in
        // decrementing the reference count and if required
        // deleting the object.   
    }

    rCPtr& operator=(const T* right)
    {
        // Use copy and swap idiom.
        rCPtr   newRef(right);
        swap(newRef);
        return *this;
    }

    // Trivial operators.
    // kep these as one liners.
    T* operator->() const          {return ptr; }
    T& operator*() const           {return *ptr;}
    const T& get() const           {return *ptr;}
    long getRefCount() const       {return refCount ? *refCount : 0;}

    bool exists() const            {return ptr != nullptr;}    
    explicit operator bool() const {return exists();}

    template <class X>
    X* dCast()
    {
        // X must be polymorphic, or else the cast will fail and cause a compiler error.
        return dynamic_cast<X*>(ptr);
    }

};