Why is the copy constructor called when we pass an object as an argument by value to a method?

by

To elaborate the two answers already given a bit:

When you define variables to be “the same as” some other variable, you have basically two possibilities:

ClassA aCopy = someOtherA; //copy
ClassA& aRef = someOtherA; //reference

Instead of non-const lvalue references, there are of course const references and rvalue references. The main thing I want to point out here is, that aCopy is independent of someOtherA, while aRef is practically the same variable as someOtherA, it’s just another name (alias) for it.

With function parameters, it’s basically the same. When the parameter is a reference, it gets bound to the argument when the function is called, and it’s just an alias for that argument. That means, what you do with the parameter, you do with the argument: 

void f(int& iRef) {
  ++iRef;
}

int main() {
  int i = 5;
  f(i); //i becomes 6, because iRef IS i
}

When the parameter is a value, it is only a copy of the argument, so regardless of what you do to the parameter, the argument remains unchanged.

void f(int iCopy) {
  ++iCopy;
}

int main() {
  int i = 5;
  f(i); //i remains 5, because iCopy IS NOT i
}

When you pass by value, the parameter is a new object. It has to be, since it’s not the same as the argument, it’s independent. Creating a new object that is a copy of the argument, means calling the copy constructor or move constructor, depending on whether the argument is an lvalue or rvalue.
In your case, making the function pass by value is unnecessary, because you only read the argument.

There is a Guideline from GotW #4:

Prefer passing a read-only parameter by const& if you are only going to read from it (not make a copy of it).

More Related Contents:

  1. What is The Rule of Three?
  2. Conditions for automatic generation of default/copy/move ctor and copy/move assignment operator?
  3. Why must the copy assignment operator return a reference/const reference?
  4. Is passing pointer argument, pass by value in C++?
  5. Copy constructor and = operator overload in C++: is a common function possible?
  6. Where should I prefer pass-by-reference or pass-by-value?
  7. Is it better in C++ to pass by value or pass by reference-to-const?
  8. When do we have to use copy constructors?
  9. Is the pass-by-value-and-then-move construct a bad idiom?
  10. Copy constructor is not inherited
  11. Why is this code trying to call the copy constructor?
  12. The copy constructor and assignment operator
  13. How are C++ array members handled in copy control functions?
  14. Const correctness for value parameters
  15. C++ – passing references to std::shared_ptr or boost::shared_ptr
  16. Can we return objects having a deleted/private copy/move constructor by value from a function?
  17. Disable copy constructor
  18. constructor invocation mechanism
  19. What exactly is the difference between “pass by reference” in C and in C++?
  20. pass by reference and value with pointers [duplicate]
  21. Pass by reference and value in C++
  22. Performance cost of passing by value vs. by reference or by pointer?
  23. Why C++ copy constructor must use const object?
  24. Explicit copy constructor
  25. Calling assignment operator in copy constructor
  26. Why am I not provided with a default copy constructor from a volatile?
  27. Uniform initialization fails to copy when object has no data members
  28. Why aren’t copy constructors “chained” like default constructors and destructors?
  29. C++ Copy constructor gets called instead of initializer_list
  30. C++ copy-construct construct-and-assign question

Leave a Comment