Template with static functions vs object with non-static functions in overloaded operator

Question

Which approach is the better one and why?

template<typename T>
struct assistant {
    T sum(const T& x, const T& y) const { ... }
};

template<typename T>
T operator+ (const T& x, const T& y) {
    assistant<T> t;
    return t.sum(x, y); 
}

Or

template<typename T>
struct assistant {
    static T sum(const T& x, const T& y) { ... }
};

template<typename T>
T operator+ (const T& x, const T& y) {
    return assistant<T>::sum(x, y); 
}

To explain the things a bit more: assistant has no state it only provides several utility functions and later I can define template specialization of it to achieve a different behavior for certain types T.

I think for higher optimization levels these two approaches don't lead to different byte codes because anyway the assistant will optimized "away"...

Thanks!

Answer 1

In the first method an assistant has to be created while the second method consists of just the function call, thus the second method is faster.

Answer 2

Since assistant is essentially a collection of free functions, I would go with the static approach (maybe even make the constructor private). This makes clear that assistant is not intended to be instatiated. Also, and this is only a wild guess, this may result in slightly less memory consumption, since no implicit this-pointer (and no instance of the class) is needed.

Answer 3

I'd use the object approach - it seems a bit more standard and similar to the way you pass functors to STL algorithms - it's also easier to extend by allowing parameters passed to the constructor of the assistant to influence the results of the operations etc. There's no difference but the object approach will probably be more flexible long term and more in sync with similar solutions you'll find elsewhere.

---

Why an object is more flexible? One example is that you can easily implement more complex operations (like average in this example) that require you to store the temporary result "somewhere" and require analyzing results from a couple invocations while still keeping the same "paradigm" of usage. Second might be you'd want to do some optimization - say you need a temporary array to do something in those functions - why allocate it each time or have it static in your class and leave hanging and waste memory when you can allocate it when it's really needed, re-use on a number of elements but then release when all operations are done and the destructor of the object is called.

There's no advantage to using static functions - and as seen above there are at least a few advantages to using objects so the choice is rather simple imho.

Also the calling semantics can be practically identical - Assistant().sum( A, B ) instead of Assistant::sum( A, B ) - there's really little reason to NOT use an object approach :)

Answer 4

It is usually not a question of run-time performance, but one of readability. The former version communicates to a potential maintainer that some form of object initialization is performed. The latter makes the intent much clearer and should be (in my opinion) preferred.

By the way, what you've created is basically a traits class. Take a look at how traits are done in the standard library (they use static member functions).

Answer 5

2nd method is preferred, in this method, there is no strcutre "assistent" variable created and it is calling only required member function. I think it is little bit faster in execution than 1st method.