一个巧妙的类型转换

#include <iostream>
using namespace std;
//class B{};
template<typename T>
class Ptr
{
private:
   class Tester {
  private:
    /** Disable delete (by virtue that this is unimplemented). */
    void operator delete (void *);
  };
public:
    Ptr(){m_ptr=0;}
    Ptr(T *ptr){m_ptr=ptr;}
    Ptr(Ptr const &o)
    {
        m_ptr=o.m_ptr;
    }
    ~Ptr(){}
    T* operator->(){return m_ptr;}
    operator Tester *()const;
    //operator B*();
private:
 T*m_ptr;
};
template <typename T>
Ptr<T>::operator Tester * () const
{
  if (m_ptr == 0)
    {
      return 0;
    }
  static Tester test;
  return &test;
}
/*template <typename T>
Ptr<T>::operator B*()
{
    return 0;
}*/
class Test
{
public:
    Test(int i):m_i(i){}
    ~Test(){}
    int GetIndex(){return m_i;}
private:
    int m_i;
};
void fun(Ptr<Test>obj)
{
    if(obj!=0)
    {
        printf("%d\n",obj->GetIndex());
    }else
    {
        printf("is null\n");
    }
}
int main()
{
    Test *test=new Test(2);
    Ptr<Test> obj;
    fun(obj);
    obj=Ptr<Test>(test);
    if(obj!=0)
    {
        printf("%d\n",obj->GetIndex());
    }
    fun(obj);
    return 0;
}

 我在学习ns3中的Ptr中，关于Ptr中的封装的类型不为空的判断，令我十分困惑，就是这一句（if(obj!=0)）以上代码并没有重载！=运算符，而且，似乎也没有发生什么隐式转换，但是以上代码可以正确运行。这个巧妙的地方就是Ptr类中内嵌了一个Tester类，而且实现一个转换算子，operator Tester * ()。就是说，编译器遇见obj!=0这个操作时，因为左右对象不一致，会隐式地调用operator Tester * ()这个函数，进行对象转换。如果m_ptr不为零，函数返回类Tester test的地址，使得！=号左右可以进行比较。
 我在代码里增加了一个class B，不过注释掉了。把相应的注释去掉，在编译的时候，就会遇见”error: ambiguous overload for ‘operator!=’ (operand types are ‘Ptr’ and ‘int’)”，这个错误，就不会调用隐式转换函数了，提醒我们需要重载!=。

convert InetSocketAddress to Address

   char *ip="127.0.0.1";
   uint16_t port=1234;
   Address  remoteAddr=InetSocketAddress{ip,port};
   Ipv4Address ipv4=InetSocketAddress::ConvertFrom (remoteAddr).GetIpv4 ();
   uint16_t myport=InetSocketAddress::ConvertFrom (remoteAddr).GetPort();
   NS_LOG_INFO(ipv4<<" "<<myport);