Question

In order to improve code readability, sometimes I use “alias methods”. These are basically methods that all do the same thing (at least in the base class; derived classes may do it differently) with different names, that enhance code readability for the class user depending on the context. Consider the code below for an example:

template <typename T>
class Foo {
public:

    T bar() { /* Lots of stuff here */ }

    inline T bar_alias1() { return this->bar(); }
    inline T bar_alias2() { return this->bar(); }
};

Of course, if Foo::bar() was a small function, one would simply duplicate the code in all the alias methods. However, since the code may be relatively large, code duplication should be avoided, hence why the alias methods are declared as inline. But I know that the compiler does not guarantee that any function declared as inline would actually end up being expanded at compile time.

So my question is, am I introducing any performance overhead by creating these alias methods? In the code below:

Foo<BIG_OBJECT> foo;
BIG_OBJECT bo1 = foo.bar();
BIG_OBJECT bo2 = foo.bar_alias1();

Would calling foo.bar() be faster than calling foo.bar_alias1() assuming the object being passed is relatively large? Are there redundant copies of the object being made when Foo::bar_alias1() calls Foo::bar()?

I’m using Visual Studio 2010 as my compiler.

Answer 1

Assuming the aliased functions are inlined – and they should given the size.
There shouldn’t be any performance overhead. The code-size won’t increase either if the compiler decides to omit the function code and inline all calls to it.

(I’m referring to the inlining of bar_alias1(), bar() itself won’t necessarily be inlined if it’s large.)

However, this doesn’t apply if the functions are virtual.

In C, I would do this more directly with preprocessor, but I’m not sure how appropriate that is in C++.