Question

In keeping with the practice of using non-member functions where possible to improve encapsulation, I’ve written a number of classes that have declarations which look something like:

void auxiliaryFunction(
        const Class& c,
        std::vector< double >& out);

Its purpose is to do something with c‘s public member functions and fill a vector with the output.
You might note that its argument order resembles that of a python member function, def auxiliaryFunction(self, out).

However, there are other reasonable ways of choosing the argument order: one would be to say that this function resembles an assignment operation, out = auxiliaryFunction(c). This idiom is used in, for example,

char* strcpy ( char* destination, const char* source );

What if I have a different function that does not resemble a non-essential member function, i.e. one that initializes a new object I’ve created:

void initializeMyObject(
    const double a,
    const std::vector<double>& b,
    MyObject& out);

So, for consistency’s sake, should I use the same ordering (mutable variable last) as I did in auxiliaryFunction?

In general, is it better to choose (non-const , const) over (const, non-const), or only in certain situations? Are there any reasons for picking one, or should I just choose one and stick with it?

(Incidentally, I’m aware of Google style guide‘s suggestion of using pointers instead of non-const references, but that is tangential to my question.)

Answer 1

The STL algorithms places output (non-const) values last. There you have a precedent for C++ that everyone should be aware of.

I also tend to order arguments from important, to less important. (i.e. size of box goes before box-margin tweak value.)

(Note though: Whatever you do, be consistent! That’s infinitely more important than choosing this or that way…)