template<class T> struct CObject
{
    CNexusObject *    Object = nullptr;

    CObject(){}
    CObject(CNexusObject * o) : Object(o)
    {
    }

    bool operator == (const CNexusObject * o) const 
    {
        return Object && Object == o;
    }

    T * operator->()
    {
        return dynamic_cast<T *>(Object);
    }

    operator T * () const
    {
        return dynamic_cast<T *>(Object);
    }
};

int main()
{
    CObject<CNexusObject> a;
    CNexusObject * b = nullptr;

            
    if(a == b)   // нужно чтобы вызывался мой оператор ==, вместо этого: error C2666: 'CObject<CNexusObject>::operator ==': 2 overloads have similar conversions
    {
    }
}

if(a.operator ==(b))

B>template<class T> struct CObject
B>{
B>    CNexusObject *    Object = nullptr;

B>    CObject(){}
B>    CObject(CNexusObject * o) : Object(o)
B>    {
B>    }

B>    bool operator == (const CNexusObject * o) const 
B>    {
B>        return Object && Object == o;
B>    }

B>    T * operator->()
B>    {
B>        return dynamic_cast<T *>(Object);
B>    }

B>    operator T * () const
B>    {
B>        return dynamic_cast<T *>(Object);
B>    }
B>};

B>int main()
B>{
B>    CObject<CNexusObject> a;
B>    CNexusObject * b = nullptr;

            
B>    if(a == b)   // нужно чтобы вызывался мой оператор ==, вместо этого: error C2666: 'CObject<CNexusObject>::operator ==': 2 overloads have similar conversions
B>    {
B>    }
B>}
B>

#include <iostream>
#include <cassert>

template<class T>
class CObject
{
private:
    T* m_Object = nullptr;

public:

    CObject() = default;
    explicit CObject(T* o) : m_Object(o) {  }

    T* get() const { return m_Object; }

    explicit operator bool() const { return m_Object != nullptr; }
    T* operator->() const { assert(m_Object); return m_Object; }
    T& operator* () const { assert(m_Object); return *m_Object; }
};

template <typename T>
bool operator == (const CObject<T>& lhs, const CObject<T>& rhs) { return lhs.get() == rhs.get(); }

template <typename T>
bool operator == (T* lhs, const CObject<T>& rhs) { return lhs == rhs.get(); }

template <typename T>
bool operator == (const CObject<T>& lhs, T* rhs) { return lhs.get() == rhs; }

template <typename T>
bool operator != (const CObject<T>& lhs, const CObject<T>& rhs) { return lhs.get() != rhs.get(); }

template <typename T>
bool operator != (T* lhs, const CObject<T>& rhs) { return lhs != rhs.get(); }

template <typename T>
bool operator != (const CObject<T>& lhs, T* rhs) { return lhs.get() != rhs; }

int main()
{
    class CNexusObject;

    CObject<CNexusObject> a;
    CNexusObject * b = nullptr;

    if(a == b)
    {
        std::cout << "Well done!" << std::endl;
    }
}

a == b 
или
a.get() == (CObject *)b

Core->Manager
или
m_core.get()->get_manager()

B>a == b 
B>или
B>a.get() == (CObject *)b

Core->>Manager
B>или
B>m_core.get()->get_manager()
B>

    if(a == b)
    {
        std::cout << "Well done!" << std::endl;
    }

CObject<CNexusObject> a;
CNexusObject * b = nullptr;

if(a == b)   
{
}