1 类类型转换

在C++中，类只要满足特定的条件就可以从类对象转换到基本类型或其他类类型对象，也可以从基本类型或其他类类型对象转换到该类对象。1.1和1.2节讲述只两种转换的操作方法以及注意事项。

1.1 class到其他对象

一个class对象要转换到其他类型的对象，需要重载类型转换操作符（Conversion Operator）。类型转换操作符是一种特殊的成员函数，它负责将一个类类型的值转换成其他类型。类型转换操作符的一般形式：
operator type() const;
**
注意：
1.类型转换操作符没有返回值；
2.type可以是除了void之外，任意能够作为函数返回值的类型；
3.一般类型转换操作符都不会修改类数据成员的值，因此一般声明为const；
4.类型转换操作符是不可以带有参数的；
5.类型转换操作符必须是类的成员函数。
**
在实现上，一般很少有类提供类型转换操作符，但是有一个例外，类定义向bool类型的转换还是比较常见的。比如我们经常使用输入输出流，文件流和字符流都定义了从类对象到bool对象的转换。有了这种转换我们就可以很方便的编写判断文件打开是否成功、文件读取/写入是否成功的代码，像 if(cin)或者while(cin >> val)。如果没有这种转换，对while的判断我们可能就要这样写:

    while(1){
    cin >> val;
    if (cin.good()){//do someting.}
    }

相较之下，方便程度力见。在使用C++的语法元素上，标准库是最有说服力的。因此，下面我们看下标准库的basic_istream::sentry是如何实现类型转换的。

template<typename _CharT, typename _Traits>
class basic_istream<_CharT, _Traits>::sentry
{
  // Data Members.
  bool _M_ok;
public:
  explicit
  sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
#if __cplusplus >= 201103L
  explicit
#endif
  operator bool() const
  { return _M_ok; }
};

从sentry的实现中，我们可以看到类型转换操作符声明上虽然没有返回值，但是需要返回一个type类型的对象（这里就是bool)。
类型转换操作符一般都是隐式进行的，因此可能出现会产生意料之外的结果，为了限制编译器在非bool上下文中进行隐式转换，C++11引入了显式的类型转换符，形式如下：
explicit operator type() const
通过在声明中添加explicit关键字来要求编译器只能在bool上下文中使用类型转换。

1.2 其他对象到class

通过定义只带一个参数的构造函数可以实现其他对象到类对象的隐式类型转换。我们通过一个示例来看下如何编写从其他类型到class对象的隐式转换。
代码

#include <iostream>
using namespace std;
class A
{
    double m_data;
public:
    A(double x):m_data(x){cout << "A::ctor(x)" << endl;}
    void print()const{cout << m_data << endl;}
};
int main()
{
    A a(1);
    a.print();  //输出a=1
    a = 3;
    a.print();  //输出a=3
}

程序输出结果：

A::ctor(x)
1
A::ctor(x)
3

从程序的输出结果可以看出在执行a=3时，编译器会先调用构造函数将数值3转换成类A的对象，然后再执行赋值操作。因此，我们可以用类似的方式来实现其他对象向类对象的隐式转换。
虽然，编译器的这种隐式类型转换是很方便的，但是，我们有时候并不希望编译器进行隐式类型转换，这时候可以在构造函数的声明前添加explicit关键字来阻止编译器的隐式转换。

2 like-classes

C++有两种很特别的类，pointer like class和function like class。pointer like class的行为像指针，function like class的行为像函数。

2.1 pointer like class

pointer like class通过重载操作符*,->,++,--等其中的一部分或全部来使类具有像指针一样的行为。pointer like class主要的用途有两个：智能指针和迭代器。本文不打算从pointer like class用途的角度来描述,本文主要从操作符重载的角度来描述怎样实现一个pointer like class.
一般pointer like class都要实现两个操作符，解引用操作符（*）和箭头操作符（->）。实现的示例如下：

template<typename T>
class SmartPtr{
    public:
        SmartPtr(T *p):px(p){}
        T& operator*(){return *px;}
        T* operator->(){return px;}
    private:
        T *px;
}

当我们定义好类SmartPtr以后，我们就可以像指针一样使用它。如：

struct s{int no;};
SmartPtr<s> sp = new s;

然后对sp我们可以进行解引用*sp和访问对象成员sp->no。
**
注意：
1.箭头操作符必须是类成员函数。解引用操作符通常是类成员函数。
2.重载的箭头操作符必须返回类的指针或者重载了箭头操作符的摸个类的对象。
**

2.2 function like class

如果类重载了函数调用操作符，则我们就可以像函数一样使用该类的对象，因此我们称这种类为function like class.由于类可以存储状态因此会比一般的函数更加灵活。
语法：
return-type operator()(param_type1 param1, param_type2 param2,...);
注意：函数调用操作符必须是成员函数。
我们来看一个示例：

struct absInt{
    int operator()(int x){
        return x > 0 ? x : -x;
    }
}

3 引用

3.1 语法

引用定义的一般形式为type& var = defined_var;或者consts type& var = defined_var;
引用是变量的别名，因此引用在定义的时候就要进行初始化。当使用引用时就和使用变量是一致。如下：

int x = 3;
int &r = x;  //定义引用
r = 5;   //对引用复制就是对变量x复制，此时x的值就是5.

3.2 常见用途及注意事项

1.很少用于变量声明，一般用于参数传递和返回类型的描述。
2.引用类型的&符号并不能作为函数签名
3.引用定义时就要进行初始化。