class模板的朋友有问题

Question

I am trying to create some friends functions for my class template. I know you have to declare them outside the class first but I am having some weird results.

...

template <typename T>
class Matrix;

template <typename T>
std::ostream& operator<<(std::ostream& os, const Matrix<T>& mtrx);
template <typename T>
std::istream& operator>>(std::istream& is, const Matrix<T>& mtrx);
template <typename T>
Matrix<T> operator*(const T& t, const Matrix<T>& mtrx);

template <typename T>
class Matrix
{
public:

    friend std::ostream&    operator<< <>(std::ostream&, const Matrix&);
    friend std::istream&    operator>> <>(std::istream&, const Matrix&);

    Matrix                  operator*(const T&) const;
    friend Matrix<T>        operator* <>(const T& t, const Matrix& mtrx);
};

...

The two stream operators work fine for me, but the multiplication operator has issues. For some reason the compiler (Visual Studio) seems to think I am trying to declare a data member and keeps throwing a bunch of errors. Like

C2460 uses Matrix which is being defined; 
C2433 friend not permitted on data declarations; 
c2473 looks like a function definition, but there is no parameter list.

As far as I can tell, the implementation is the same as for the stream operators which work. Also, if I rename operator* to something else, like foo, it works fine.

Now, I don't actually need to make this function a friend, my definition just reverses order of arguments and calls the member function version. But I still want to know what is going on and what is wrong.

Answer 1

There are two things at play here.

First

A C++ compiler is permitted (but not required.) to diagnose errors at the time the template is parsed when all of the instantiations of the template would produce that error.

This means that since you've not instantiated class template Matrix , compilers are free to diagnose the error. For example, the given program is rejected by msvc but accepted(compiled) by gcc and clang in C++20. Demo .

So this is not msvc bug. For more detailed explanation of this, refer to Template class compiles with C++17 but not with C++20 if unused function can't be compiled .

Note also that if you do instantiate Matrix for some template argument say by writing Matrix<int> , then the program is also rejected by gcc. Demo . See reason why this is rejected.

---

Important

The important thing to note here is that the exact same program is rejected by all compilers with C++17 irrespective of whether you instantiate Matrix for a given template argument or not. Demo

---

Second

Now, lets see the reason for the program being rejected with all compilers in C++17.

In your given program when you try to befriend a specialization of the function template operator* , the compiler starts lookup(looking up) for an operator* and it finds the non-template overloaded version and so stops looking further . Now, since it found a nontemplate version which cannot be specialized, it gives the error in all compilers.

Lets, look at a contrived example:

template<typename T> void f(T){

}
template <typename T>
class Matrix
{
public:


    int                  f(const T&) const; //#1
    friend void          f<>(const Matrix& mtrx); //lookup find #1 and stops looking and so gives error
    
};;

int main()
{
    Matrix<int> m;
}

To solve the above error, it we've to reorder the declarations so that the lookup for operator* isn't found when befriending the specialization.

This means we have to change the above program to:

template<typename T> void f(T){ //#2

}
template <typename T>
class Matrix
{
public:


    
    friend void          f<>(const Matrix& mtrx); //lookup find #2  
    int                  f(const T&) const; //OK now
};;

int main()
{
    Matrix<int> m;
}

---

Summary

To solve the error you're getting you've to reorder the declarations for operator* like shown below:

template <typename T>
class Matrix
{
public:

    friend std::ostream&    operator<< <>(std::ostream&, const Matrix&);
    friend std::istream&    operator>> <>(std::istream&, const Matrix&);

    //reordered 
    friend Matrix<T>        operator* <>(const T& t, const Matrix& mtrx);
    Matrix                  operator*(const T&) const;
};

Demo