Thread: Argument passing vs copy initialization

Hi. On page 4 of "A Tour of C++", Bjarne Stroustrup writes:

The semantics of argument passing are identical to the semantics of copy initialization.

I'm not sure that I fully understand this. Is there some example code that will demonstrate this? Is it possible to "trap" any copy initialization that occurs in argument passing?

Richard

You'll need to provide more content, not everyone will have access to that book.

The following demonstrates this to some extent:

Code:

int by_value(std::string test);

When this function is called a copy of test will be made by calling the std::string copy constructor. Remember, by default parameters are passed by value. To avoid the copy you can pass the parameter by reference/const reference.

Is it possible to "trap" any copy initialization that occurs in argument passing?

What do you mean by "trap"? For non-standard classes you can create your own copy constructor to illustrate or possibly "trap" this behavior.

What about this?

Code:

#include <iostream>

class Foo {
  public:
    Foo()      : x {}  {}
    Foo(int n) : x {n} {}
    Foo(const Foo& rhs) {
      std::cout << "Copy constructor" << std::endl;
      x = rhs.x;
    }
  private:
    int x;
};

void fn(Foo f) {
}

int main() {
  Foo f;
  fn(f);
}

Overloading the assignment operator as well does not change what the program prints.

When arguments are passed by value, the copy constructor is invoked. If you want to "trap" anything it would be in there. Assignment is never involved. unless for some reason the copy constructor is written in terms of it.