// ...
typedef intrusive_ptr this_type; 

// ...
    intrusive_ptr & operator=(intrusive_ptr const & rhs)
    {
        this_type(rhs).swap(*this); // const_cast ???
        return *this;
    }

    intrusive_ptr & operator=(T * rhs)
    {
        this_type(rhs).swap(*this); // static_cast ???
        return *this;
    }

// ...

O>Во как! Это я и не подумал. Считал, что вызывается метод swap у rhs, а не у временного объекта. Мозгодробительно, имхо.

#include <stdio.h>

struct A { 
  A(...) {
    printf("*");
  }
};

int main()
{
   A three(666, 666, 666);
   A two(666, 666);
   A one(666);
   A zero();
}

#include <stdio.h>

struct A { 
  A(...) {
    printf("*");
  }
};

template <class T> struct Main : public T
{
    static void Run()
    {
        A x(T::foo);
    }
};

struct Ansi {
    typedef int foo;
};

struct Unicode {
    enum { foo };
};

int main()
{
    Main<Ansi>::Run();
    Main<Unicode>::Run();
}

R>Но каким образом это связано с топиком, я не понял

#include <stdio.h>

struct A { 
  A(...) {
    printf("*");
  }
//  int operator ()(){return 0;} //(1)
};

template <class T> struct Main : public T
{
    static void Run()
    {
        A x(T::foo);
        x();
    }
};

struct Ansi {
    typedef int foo;
};

struct Unicode {
    enum { foo };
};

int main()
{
    Main<Ansi>::Run();
}

"ComeauTest.c", line 15: error: call of an object of a class type without
appropriate operator() or conversion functions to
pointer-to-function type
x();
^

"ComeauTest.c", line 15: error: too few arguments in function call
x();
^

"ComeauTest.c", line 15: error: too few arguments in function call
x();
^
detected during instantiation of "void Main<T>::Run() [with T=Ansi]"
at line 29

1 error detected in the compilation of "ComeauTest.c".

#include <stdio.h>

struct A { 
  A(...) {
    printf("*");
  }
  int operator ()(){return 0;}
};

template <class T> struct Main : public T
{
    static void Run()
    {
        A x(T::foo);
        x(1);
    }
};

struct Ansi {
    typedef int foo;
};

int main()
{
    Main<Ansi>::Run();
}

"ComeauTest.c", line 15: error: no instance of function "A::operator()" matches the
argument list
The argument types that you used are: (int)
object type is: A
x(1);
^

1 error detected in the compilation of "ComeauTest.c".

#include <stdio.h>

struct A { 
  A(...) {
    printf("*");
  }
private:
  int operator ()(int){return 0;}
};

template <class T> struct Main : public T
{
    static void Run()
    {
        A x(T::foo);
        x(1);
    }
};

struct Ansi {
    typedef int foo;
};

int main()
{
    Main<Ansi>::Run();
}

L_L>#include <stdio.h>

L_L>struct A { 
L_L>  A(...) {
L_L>    printf("*");
L_L>  }
L_L>private:
L_L>  int operator ()(int){return 0;}
L_L>};

L_L>template <class T> struct Main : public T
L_L>{
L_L>    static void Run()
L_L>    {
L_L>        A x(T::foo);
L_L>        x(1);
L_L>    }
L_L>};

L_L>struct Ansi {
L_L>    typedef int foo;
L_L>};

L_L>int main()
L_L>{
L_L>    Main<Ansi>::Run();
L_L>}
L_L>

#include <stdio.h>

struct A { 
  A(...) {
    printf("*");
  }
};

template <class T> struct Main : public T
{
    static void Run()
    {
        A x(T::foo);
        typedef A Y(typename T::foo);
        Y* y = x;
        y(123);
    }
};

struct Ansi {
    typedef int foo;
};

int main()
{
    Main<Ansi>::Run();
}

class X
{
};

template<class T>
class A
{
public:
   A()
   {
      X a(T::foo);
      a = 10;
   }
};

"ComeauTest.c", line 12: error: no operator "=" matches these operands
operand types are: X = int
a = 10;
^

class X
{
};

template<class T>
class A
{
public:
   A()
   {
      X a(T::foo);
   }
};

struct XX
{
   typedef int foo;
};

A<XX> a;

error: dependent-name `T::foo' is parsed as a non-type, but instantiation yields a type

warning C4930: 'A x(Ansi::foo)': prototyped function not called (was a variable definition intended?)

struct A {
} x[1];
template <A* m> struct B {
  B(int) {}
};
int main()
{
    new A<x>(0);
    new B<x>(0);
}

O>// ...
O>    intrusive_ptr & operator=(intrusive_ptr const & rhs)
O>    {
O>        this_type(rhs).swap(*this); // const_cast ???
O>        return *this;
O>    }
O>

O>    intrusive_ptr & operator=(intrusive_ptr rhs)
    {
        rhs.swap(*this); // const_cast ???
        return *this;
    }

1.3.13 unspecified behavior
behavior, for a well-formed program construct and correct data, that depends on the implementation. The
implementation is not required to document which behavior occurs.