When is an object sufficiently large that there is a performance gain in passing it by reference instead of by value?

Question

As answered in this question by Charles Bailey pass by constant reference should be considered when the object type is large but what kind of object is considered large?

EDIT: OK for providing more data that could be used to provide a more concrete answer I decided to add a real world problem to this description.

Suppose we have an object like this:

typedef struct dipl {
    quint16 __id;
    quint16 __pos;
    quint16 __len;
} data;

And we have another object like this:

class bidipl
{
public:
    bidipl();
    quint8 id();
    void setid(quint8 __id);
    void appenddipl(dipl __dipl);
private:
    qint8 _M_id;
    dipllist _M_dipllist;
};

Where dipllist is typedef QList<dipl> dipllist;. Objects dipl and bidipl are created once but accessed over maybe 100 times a minute. So how should we pass dipl to our append function?

void appenddipl(dipl __dipl);

Or

void appenddipl(const dipl& __dipl);

Answer 1

There are two separate costs associated with passing objects by value: Copying the data representation, and executing constructors. You need to consider the cost of both.

• Copying data is generally fast, but keep it within reason. It's OK to pass struct { int[7]; } by value, but probably not so much for struct { int[20000]; }.

• Executing constructors may perform dynamic allocation, which brings the risk of exceptions and the cost of synchronization. This may be negligible, or it may be important. It depends.

The only variables you should probably pass by value unconditionally are those of word-sized, built-in types. For everything else you should think about the trade-offs.