Copy Constructor

[Salih Dincer via Digitalmars-d-learn]

Hi,

Let be the structure Foo that wraps an int pointer. Let's setup 
Foo in 3 different ways:
1. Foo one = Foo(1);
2. Foo two = 2;
3. [ Foo(3) ];

Pretty clean, right?

So why it's not run copy-constructor in 3? Also, when we write to 
the screen with writeln(), why four times copy-constructors are 
running?

**Playground:** https://run.dlang.io/is/qHvLJe
**Source:**
```d
struct Foo {
  int payload;

  this(int i)
  {
    this.payload = i;
  }

  this(ref return scope Foo that)
  {
    this = that; //cC = copyConstructor
    logger ~= format("cC(%s)", that.payload);
  }

  Foo opUnary(string op)()
  if(op == "++") {
    ++this.payload;
    return this;
  }

  int getter()
  {
    return payload;
  }
  alias getter this;
}

import std.stdio, std.format;
string logger;

void main() {
  Foo one = Foo(1), two = 2;
  int[] arr = [one, two, Foo(3)];

  auto three = ++two;/*
  two.writeln(": 0x", &two.payload);//*/

  //arr.writeln;/*
  foreach(ref i; arr) {
    i.writeln(": 0x", &i);
  }//*/

  writeln("0x", &three.payload);

  logger.writeln;
} // end with the logger!
/*
Print Outs:
=================
1: 0x7FD13D561000
2: 0x7FD13D561004
3: 0x7FD13D561008
0x7FFE6757E908
cC(1)cC(2)cC(3)
*/
```

SDB@79