"const T &arg" vs. "T arg"

Question

Which of the following examples is the better way of declaring the following function and why?

void myFunction (const int &myArgument); 

or

void myFunction (int myArgument); 

Answer 1

Use const T & arg if sizeof(T)>sizeof(void*) and use T arg if sizeof(T) <= sizeof(void*)

Answer 2

They do different things. const T& makes the function take a reference to the variable. On the other hand, T arg will call the copy constructor of the object and passes the copy. If the copy constructor is not accessible (e.g. it's private), T arg won't work:

class Demo {     public: Demo() {}      private: Demo(const Demo& t) { }  };  void foo(Demo t) { }  int main() {     Demo t;     foo(t); // error: cannot copy `t`.     return 0; } 

For small values like primitive types (where all matters is the contents of the object, not the actual referential identity; say, it's not a handle or something), T arg is generally preferred. For large objects and objects that you can't copy and/or preserving referential identity is important (regardless of the size), passing the reference is preferred.

Another advantage of T arg is that since it's a copy, the callee cannot maliciously alter the original value. It can freely mutate the variable like any local variables to do its work.