In an earlier lesson, you learned about the keyword inline, which is a request to the compiler that the function be compiled without function call overhead. The compiler may ignore this suggestion, but either way the semantics of the compiled functions are identical.
Use inline in place of using the preprocessor define directive that you're familiar with in C programming.

Using the preprocessor to define macros has a clear drawback: the preprocessor does not understand C syntax. For example:

#define SQ(X)  X * X

SQ(a + b)

a + b * a + b

a + (b * a) + b

(a + b) * (a + b)

inline int SQ(int x) { return (x * x); }

Because the keyword inline requests that the compiler compile the function without function call overhead, you should only use inline for very short functions, for which function overhead is an issue.

When function bodies are very short, such as with the comparison operators in class Fraction, the execution time involved in the function call (pushing arguments on to the activation record stack, transfer of control, return from function, popping arguments off the stack) can often be greater than the execution time required by the body of the function itself. Moreover, many processors fetch and decode subsequent instructions as they execute an instruction. Branches and function calls slow down this mechanism. When an inline function is invoked, the compiler expands the body of the function in place. This eliminates the execution cost of the function call, but results in multiple copies of the function body (one each time the function is called).
For this reason, inline functions should only be used when the function body is very short. To create an inline function the keyword inline is placed before the function body. The function definition is then placed in the interface file, not the implementation file:

inline bool operator<(const Fraction& left, const Fraction& right){
 return left.compare(right) < 0;
}

inline Fraction& Fraction::operator++(){
 top += bottom;
 return *this;
}

class Fraction{
  //...
  Fraction& Fraction::operator++(){
    top += bottom;
    return *this;
  }
  //...
};