Virtual function calls at compile time

[Sorry, I mistakenly posted this in comp.std.c++. It was my first
post, so I didn't receive the information about the group until after
I received an email from Robo moderator]

{ It's fine, as long as your post didn't make it to any wrong group. :)
  -mod }

Hello. I have a question regarding the performance cost of virtual
function call

class _Traits {
public:
    virtual int & value () = 0;

    void multiply () {
        value() = value() * 2;
    }
};

class Number : public _Traits {
public:
    int k;

    Number(int n) : k(n) {}

    int & value () {
        return k;
    }
};

void funcA(Number a) {
    // This can be optimised right? - it won't be a virtual lookup?
    a.multiply();
}

void funcB(Number &a) {
    // How about here?
    a.multiply();
}

void funcC(Number *a) {
    // And here?
    a->multiply();
}

int main (int argc, char ** argv) {
    Number n(5);

    funcA(n);
    funcB(n);
    funcC(&n);
}

The compiler can optimise this code, but I'm not sure if this is
reliable behaviour across compilers. The reason why this is important
is because I use this structure for implementing traits for specific
template classes:

template <unsigned S>
class _MatrixMath<S, S> { .. specific code for square matrix .. };

template <unsigned W, H>
class _MatrixMath<W, H> { .. general code for rectangular matrix .. };

template <unsigned W, unsigned H>
class Matrix : public _MatrixMath<W, H> { float[W][H]
m_values; .... };

Obviously, the traits class _MatrixMath needs to read and write
m_values, so the easiest way is to have virtual function in
_MatrixMath such as in the first example. This simplifies code and
abstracts the API into manageable traits classes.

1: Can anyone provide some insight into the performance of the three
funcA, funcB and funcC calls?
2: Is this technique a good idea? I have used it successfully for my
Matrix class, where specific functionality must be given to square
matrix, and certain sizes (such as 4x4 matrix can do specific
rotations and translations).

This means that any problems are caught at compile time (such as
function for square matrix not available for rectangular matrix).

Any feedback would be appreciated.

Best Regards,
Samuel Williams

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]