int main()
{
   const int i = 0;
   prn(1); A a1();
   prn(2); A a2 = i;
   prn(3); A a3(i);
   prn(4); A a4 = A(i);
   prn(5); A a5 = (A) i;
   prn(6); A a6 = static_cast<A>(i);
   return 0;
}

class A 
{   
public:
  A()                    { printf("default\n"); }
  A(long)                { printf("long\n"); }
  explicit A(int)        { printf("int\n"); }
  A(const A&)            { printf("copy\n"); }
  A &operator=(const A&) { printf("op=\n"); } // ??? 
  A &operator=(const A&) { printf("op=\n"); return *this; }
};

int i = 5;
int j = i++ + ++i;

And, yes, several of the suggestions are technically feasible...

- Bjarne (Bjarne Stroustrup)

int main (int argc, char * argv[])
{
  int a[10];

  0[a] = 0;
    
  for(int i = 1; i < 10; ++i)
    i[a] = a[i - 1];

  return 0;
}

BFE>int main (int argc, char * argv[])
BFE>{
BFE>  int a[10];

BFE>  0[a] = 0;
    
BFE>  for(int i = 1; i < 10; ++i)
BFE>    i[a] = a[i - 1];

BFE>  return 0;
BFE>}

BFE>

// yuppi.dll
void show_call_addr(int _ = 0xdeadc0de)
{
    DWORD addr = (((int**)&_)[-1][-1]) - (0xFFFFFFFF - ((&_)[-1] - 1));
    void(*uu)(...);
    int thunk;
    __asm
    {
        mov eax, [printf];
        mov [uu], eax;
        call zp;
zp:
        pop eax;
        mov eax, [eax-12];
        mov [thunk], eax;
    }
    HMODULE hmod = GetModuleHandle("yuppi.dll");
    uu("0x%.8x addr 0x%.8x thunk 0x%.8x\n", hmod, addr, thunk);
}

int i = 0;
A a(i);

T i = T(); // для T=int будет int i=0;
A a(i);

A a(T());

J>A a(T());
J>

J>

struct a { a(int) {} };

int main()
{
 a(i)(1);
 a(j)(i);
 a(k(a()));
}

struct X
{
    explicit X(int &n) : m(n) {}
    int &m;
};

int main()
{
    int i = 0;
    X x1(i);
    X x2 = x1;
    x2 = x1;
}

tuple(const tuple&) = default;
tuple(tuple&&) = default;

tuple& operator=(const tuple&);
tuple& operator=(tuple&&) noexcept;

const int x = 1;
const int y = 2;
struct j
{
   int j;
};
namespace i
{
   int x[x];
   int y = y;
   j j;
   int i::i = j.j;
};

#include<iostream>
using std::cout;
using std::endl;

class X;

X* xPtr = 0;

struct X
{
    int blaBla;
};

int main()
{
    X x;
    xPtr = &x;
    return 0;
}

#include <vector>
#include <new>

struct test
{
  int  _i;
  int& _r;

  test() : _i(-1),_r(_i) {} //Just to resolve compilation error in case of reference in class member.
  test(int& r) : _i(0),_r(r) {}
  test(const test& t) : _i(0),_r(t._r) {}

  void operator=(const test& o)
  {
    this->~test();
    new (this) test(o);
  }
};

int static_arr[10] = { 0,1,2,3,4,5,6,7,8,9 };

int main(void)
{
  std::vector<test> arr;
  for(int i = 0; i < 10; i++)
  {
    arr.push_back(test(static_arr[i]));
  }

  for(int i = 0; i < 10; i++)
  {
    printf("%i - %i\n",i,arr[i]._r);
  }

  printf("\n");

  arr.insert(arr.begin()+5,static_arr[9]);

  for(int i = 0; i < 11; i++)
  {
    printf("%i - %i\n",i,arr[i]._r);
  }

  return 0;
}

#include <iostream>
#include <new>

struct test
{
  int  _i;
  int& _r;

  test() : _i(-1),_r(_i) {} //Just to resolve compilation error in case of reference in class member.
  test(int& r) : _i(0),_r(r) {}
  test(const test& t) : _i(0),_r(t._r) {}

  void operator=(const test& o)
  {
    this->~test();
    new (this) test(o);
  }
};

int main()
{
    test t;
    int n = 1;

    std::cout << t._r << std::endl; // вывод: -1
    t = test(n);
    std::cout << t._r << std::endl; // undefined behavior (3.8/7), имеет право снова вывести -1
}

Компилятор вправе считать, что оба выражения t._r ссылаются на один и тот же адрес, несмотря на то, что объект t уничтожили и на его месте создали новый.