why should the function defined in class

Item 46: Define non-member functions inside templates when type
conversions are desired
Item 24 explains why only non-member functions are eligible for
implicit type conversions on all arguments, and it uses as an example
the operator* function for a Rational class. I recommend you
familiarize yourself with that example before continuing, because this
Item extends the discussion with a seemingly innocuous modification to
Item 24's example: it templatizes both Rational and operator*:

template<typename T>

class Rational {

public:

  Rational(const T& numerator = 0, // see Item 20 for why params

           const T& denominator = 1); // are now passed by reference

  const T numerator() const; // see Item 28 for why return

  const T denominator() const; // values are still passed by
value,

  ... // Item 3 for why they're const

};

template<typename T>

const Rational<T> operator*(const Rational<T>& lhs,

                            const Rational<T>& rhs)

{ ... }

As in Item 24, we want to support mixed-mode arithmetic, so we want
the code below to compile. We expect that it will, because we're using
the same code that works in Item 24. The only difference is that
Rational and operator* are now templates:

Rational<int> oneHalf(1, 2); // this example is from Item 24,

                                      // except Rational is now a
template

Rational<int> result = oneHalf * 2; // error! won't compile

The fact that this fails to compile suggests that there's something
about the templatized Rational that's different from the non-template
version, and indeed there is. In Item 24, compilers know what function
we're trying to call (operator* taking two Rationals), but here,
compilers do not know which function we want to call. Instead, they're
trying to figure out what function to instantiate (i.e., create) from
the template named operator*. They know that they're supposed to
instantiate some function named operator* taking two parameters of
type Rational<T>, but in order to do the instantiation, they have to
figure out what T is. The problem is, they can't.

In attempting to deduce T, they look at the types of the arguments
being passed in the call to operator*. In this case, those types are
Rational<int> (the type of oneHalf) and int (the type of 2). Each
parameter is considered separately.

The deduction using oneHalf is easy. operator*'s first parameter is
declared to be of type Rational<T>, and the first argument passed to
operator* (oneHalf) is of type Rational<int>, so T must be int.
Unfortunately, the deduction for the other parameter is not so simple.
operator*'s second parameter is declared to be of type Rational<T>,
but the second argument passed to operator* (2) is of type int. How
are compilers to figure out what T is in this case? You might expect
them to use Rational<int>'s non-explicit constructor to convert 2 into
a Rational<int>, thus allowing them to deduce that T is int, but they
don't do that. They don't, because implicit type conversion functions
are never considered during template argument deduction. Never. Such
conversions are used during function calls, yes, but before you can
call a function, you have to know which functions exist. In order to
know that, you have to deduce parameter types for the relevant
function templates (so that you can instantiate the appropriate
functions). But implicit type conversion via constructor calls is not
considered during template argument deduction. Item 24 involves no
templates, so template argument deduction is not an issue. Now that
we're in the template part of C++ (see Item 1), it's the primary
issue.

We can relieve compilers of the challenge of template argument
deduction by taking advantage of the fact that a friend declaration in
a template class can refer to a specific function. That means the
class Rational<T> can declare operator* for Rational<T> as a friend
function. Class templates don't depend on template argument deduction
(that process applies only to function templates), so T is always
known at the time the class Rational<T> is instantiated. That makes it
easy for the Rational<T> class to declare the appropriate operator*
function as a friend:

template<typename T>

class Rational {

public:

  ...

friend // declare
operator*

  const Rational operator*(const Rational& lhs, // function (see

                           const Rational& rhs); // below for
details)

};

this is a example in Effectvie C++ 3e, it is said that the function
declared as a friend should also be defined in class Rational. It
proves to be true. But I really didn't understand the explanation :If
we declare a function ourselves (which is what we're doing inside the
Rational template), we're also responsible for defining that function.
Can anyone explain it more clear? thank you