C++:复习笔记3

• conversion function

class fraction
{
  public：
    fraction(int num, int den=1)
    : m_numberator(num),m_denominator(den){}
    
    operator double() const{//没有参数必须是operator开头，没有返回类型,通常加上const，因为这里
    return (double)(m_numberator/m_denomintor);//不涉及修改
    }
  private:
    int m_numerator;//分子
    int m_denominator;//分母
}

fraction f(3,5);
double d = 4+f;//调用operator double()将f转换为double

• non-explicit-one-argument ctor

class fraction
{
  public:
   fraction(int num,int den=1)//two paramters but one argument
   : m_numerator(num),m_denominator(den){}
   
   fraction operator+(const fraction& f){
     return fraction(...);
   }

  private:
    int m_numerator;//分子
    int m_denominator;//分母
}

fraction f(3,5);
fraction d2=f+4; //调用 non-explicit ctor 将4转换为fraction
                 //然后调用operator+

• 如果如下写就会报二意错误

class fraction
{
  public:
   fraction(int num,int den=1)//two paramters but one argument
   : m_numerator(num),m_denominator(den){}
   operator double() const{//没有参数必须是operator开头，没有返回类型,通常加上const，因为这里
    return (double)(m_numberator/m_denomintor);//不涉及修改
   fraction operator+(const fraction& f){
     return fraction(...);
   }

  private:
    int m_numerator;//分子
    int m_denominator;//分母
}

也就说这里有一个转换函数，有一个non explicit on argument的构造函数，还有一个
+号的重载成员函数。


fraction f(3,5);
fraction d2=f+4;//ambiguous 二意错误

因为这里有2条可选的路径可走。因此考虑在构造函数前面加上explicit，告诉编译器
不要偷偷的把4给我转换为fraction类型。及如下：

explicit fraction(int num,int den=1)//two paramters but one argument
   : m_numerator(num),m_denominator(den){}

加上后报错改为为4不能转换为fraction类型。这是在调用+操作符重载的时候传入参数必须
为fraction的引用报错来的。

• class like pointer

智能指针一定包含了一个普通的指针。

template<class T>
class shared_ptr
{
public:
  T& operator*() const
  { return *px;}
  
  T* operator->() const
  {return px;}
  
  shared_ptr(T* p):px(p){}

private:
  T* px;
  long* pn;
}

struct foo
{
  ...
  void method(void){...}
}

shared_ptr<foo> sp(new foo);

• foo f( *sp );//*号做了转换后就不存在了 *sp转换为了 *px

• sp->method();//转换为 px->method();这个转换是特殊 的-> 会继承下去