Sometimes C++ is faster

The fundamental advantage (inlined templates over macros) is that the compiler knows what's
going on.  First, it can provide type checking, which with good design can prevent many usage
errors.  Second, it can provide type-based dispatching, enabling different algorithms to be
used for different data structures.  The optimal sort for a three-element array is
fundamentally different from that for one of unknown size.  The optimal sort for a linked list
is conceptually similar to that for an array, but an entirely different code sequence.  

Using template type matching, you can present the same interface for all these cases, and
generate appropriate code for each.  Try doing that with C macros, or even Lisp macros.

You might provide macros for all the cases, under different names, but you probably wouldn't,
because you could only use them locally.  Templates may be packaged cleanly and safely enough
to be generally usable, justifying more attention to their creation and distribution.

C++ may be faster in other places.  In a deep call chain, where each caller must check and
dispatch on the return value of each call, using exceptions well instead can make the code
both faster and much more compact and readable.  A taste of the difference may be seen in
numeric codes that rely on checking for Inf and NaN at the end of a computation; imagine
checking for all those conditions after each multiply!