operator重载的奇怪用法

     对于operator重载我们见过很多了，但我今天看到了一个比较奇怪的用法。

     例：

   #include <iostream>

   using namespace std;

     ///class B;

     class A

     {

     public:

               int data[2];

     ///public:

               ///void operator = (const B& b)

               ///{cout<<"A--B"<<endl;}                      

     };   

    class B

     {

            public:

                    int x;

                    int y;

            public:

                    operator  const A() const

                    {

                             A a;

                             a.data[0] = x;

                             a.data[1] = y;

                             cout<<"B--A"<<endl;

                             return a;

                    }                   

     };   

    void main()

   {

            A a;

            B b;

           a.data[0] = 0;

           a.data[1] = 0;

            b.x = 1;

            b.y = 2;

            a = b;

            cout<<a.data[0]<<endl;

            cout<<a.data[1]<<endl;

   }

打印的结果是: 

  B--A

  1

  2

把代码里的///号全部去掉后，打印结构为:

  A--B

  0

  0

说明 a = b调用了函数 B::A() ，值得注意的是其函数里一定要有还回值。

对于类A一般要用默认构造函数，如果A用到自己的构造函数void A::operator = (const  B& b)，则B::A()无效了。 

我大概能猜的出一些为什么要这么用，可能是因为如果用void A::operator = (const  B& b)的话，假如用到B里面的成员的话一定要把B类定义在前面。但我现在假定B只能定义在A后面，且A = B 这样的操作要用到B的成员，那么只能在类B里进行了，问题是这样还要用到A的默认=操作函数，且默认=操作函数只能进行浅拷贝。

有些拿捏不定，请高手指教！