Is it necessary to overload operator in this specific case

class Rect{
     Rect( const Rect& ) = delete;
     Rect& operator=( const Rect& ) = delete;
     . . .
}

QDataStream & operator>> (QDataStream & stream, chromosome & myChromosome){

myChromosome = chromosome();

boost::optional<point> intersect(const line& a, const line& b);

enum class E {A, B};

struct C
{
    int operator [](const std::pair<E, E>& p) const
    {
        return data[static_cast<int>(p.first) * 2 + static_cast<int>(p.second)];
    }
    std::array<int, 4> data{{1, 2, 3, 4}};
};

namespace comma
{
    std::pair<E, E> operator , (E lhs, E rhs) { return { lhs, rhs }; }
}

int main()
{
    C c;

    {
        using namespace comma; // operator , is valid here.

        std::cout << c[E::A, E::B] << std::endl;
        auto p = (E::A, E::B); // but also here :/ p = {E::A, E::B}
        static_cast<void>(p);
    }
    {
        std::cout << c[E::A, E::B] << std::endl; // result in c[E::B]
        auto p = (E::A, E::B); // p = E::B
        static_cast<void>(p);
    }
}

template <size_t NUM_ROWS, size_t NUM_COLUMNS>
class matrix
{
   ...
};