ตัวดำเนินการสมาชิกที่ไม่ถูกต้องถูกอนุมานจากตัวดำเนินการส่วนกลางที่ถูกต้อง

ฉันมีคลาส 3x3 Matrix และ 3x1 Vector ฉันมีตัวดำเนินการคูณสองตัว อันหนึ่งสำหรับการคูณเมทริกซ์ด้วยสเกลาร์ อีกอันหนึ่งสำหรับการคูณเมทริกซ์ด้วยวัตถุเวกเตอร์ ตัวดำเนินการคูณเมทริกซ์-สเกลาร์เป็นสมาชิกภายในคลาส Matrix และตัวดำเนินการคูณเมทริกซ์-เวกเตอร์เป็นแบบโกลบอล

#include <initializer_list>
#include <array>

template <class T>
class Matrix
{
    public:
        Matrix(std::initializer_list<T> List);
        Matrix() : Matrix({0,0,0,0,0,0,0,0,0}) {}

        template <class S>                      // THE COMPILER TRIES TO USE
        Matrix<T> operator*(const S & Scalar);  // THIS OPERATOR IN BOTH CASES.

        const T & operator()(size_t i, size_t j) const;

    private:
        static constexpr size_t SIZE = 3;
        static constexpr size_t AREA = SIZE * SIZE;
        std::array<T, AREA> E;
};

template <class T>
Matrix<T>::Matrix(std::initializer_list<T> List)
{
    if (List.size() != AREA) throw("Error!");
    for (size_t i=0; i<AREA; i++)
    {
        E[i] = *(List.begin() + i);
    }
}

template <class T>
const T & Matrix<T>::operator()(size_t i, size_t j) const
{
    return E[SIZE * j + i];
}

template <class T>
template <class S>
Matrix<T> Matrix<T>::operator*(const S & Scalar)
{
    const T ScalarT = static_cast<T>(Scalar);
    Matrix<T> Result;
    for (size_t i=0; i<AREA; i++)
    {
        Result.E[i] = E[i] * ScalarT;
    }
    return Result;
}

template <class T>
class Vector
{
    public:
        Vector(std::initializer_list<T> List);
        Vector() : Vector({0,0,0}) {};
        const T & operator()(size_t i) const;
              T & operator()(size_t i);

    private:
        static constexpr size_t SIZE = 3;
        std::array<T, SIZE> E;
};

template <class T>
Vector<T>::Vector(std::initializer_list<T> List)
{
    if (List.size() != SIZE) throw("Error!");
    for (size_t i=0; i<SIZE; i++)
    {
        E[i] = *(List.begin() + i);
    }
}

template <class T>
const T & Vector<T>::operator()(size_t i) const
{
    return E[i];
}

template <class T>
T & Vector<T>::operator()(size_t i)
{
    return E[i];
}

template <class T>  // THE COMPILER NEVER TRIES USING THIS GLOBAL OPERATOR.
Vector<T> operator*(const Matrix<T> & Mat, const Vector<T> & Vec)
{
    Vector<T> Result;
    Result(0) = Mat(0,0) * Vec(0) + Mat(0,1) * Vec(1) + Mat(0,2) * Vec(2);
    Result(1) = Mat(1,0) * Vec(0) + Mat(1,1) * Vec(1) + Mat(1,2) * Vec(2);
    Result(2) = Mat(2,0) * Vec(0) + Mat(2,1) * Vec(1) + Mat(2,2) * Vec(2);
    return Result;
}

int wmain(int argc, wchar_t *argv[]/*, wchar_t *envp[]*/)
{
    Matrix<float> Mat1({2,  0,  0,
                        0,  2,  0,
                        0,  0,  2});

    Vector<float> Vec1({1,
                        2,
                        3});

    Matrix<float> Mat2 = Mat1 * 2;      // Matrix-Scalar Multiplication
    Vector<float> Vec2 = Mat1 * Vec1;   // Matrix-Vector Multiplication

    return 0;
}

ปัญหาคือ เมื่อฉันพยายามคูณเมทริกซ์-เวกเตอร์ คอมไพลเลอร์จะเลือกและพยายามใช้ตัวดำเนินการคูณเมทริกซ์-สเกลาร์ และทำให้คอมไพเลอร์เกิดข้อผิดพลาด

ถ้าฉันลบตัวดำเนินการคูณเมทริกซ์-สเกลาร์และบรรทัดที่ฉันใช้ โปรแกรมจะทำงานได้สำเร็จ ในทางกลับกัน ถ้าฉันลบตัวดำเนินการคูณเมทริกซ์-เวกเตอร์ มันจะรันได้สำเร็จอีกครั้ง พวกเขาแค่ไม่เข้ากัน และเมื่อมันทำงาน (ไม่ว่าในกรณีใด) การคำนวณทั้งหมดก็จะถูกต้อง

เกิดอะไรขึ้นที่นี่?

คอมไพเลอร์และ IDE: Microsoft Visual Studio 2015 Community Edition