Avoiding ambiguities

Hello,

I have the following operators declared in a class:

    // Provides R/W direct access to the matrix.
    __forceinline const T& operator[](USHORT ndx) const throw()
        { _ASSERT(ndx < 16); return(_mx[ndx]); }
    __forceinline T& operator[](USHORT ndx) throw()
        { _ASSERT(ndx < 16); return(_mx[ndx]); }

    // Returns pointer to matrix data.
    __forceinline operator const T*() const throw()
        { return(_mx); }
    __forceinline operator T*() throw()
        { return(_mx); }

When I compile it I get the following errors:

error C2666: 'Matrix4<T>::operator []' : 4 overloads have similar
conversions
        with
        [
            T=float
        ]
        d:\~alibrary\prj\cpp\xgl\0.1a1\inc\primitives.hpp(1515): could
be 'float &Matrix4<T>::operator [](USHORT) throw()'
        with
        [
            T=float
        ]
        d:\~alibrary\prj\cpp\xgl\0.1a1\inc\primitives.hpp(1513): or
'const float &Matrix4<T>::operator [](USHORT) throw() const'
        with
        [
            T=float
        ]
        or 'built-in C++ operator[(const float *, int)'
        or 'built-in C++ operator[(float *, int)'

Is there a way of avoiding these errors without having to create a
method for, say, replacing the functionality of the T* operators?