(Boolan) C++面向对象高级编程（四）

之前几次，对C++中的一些核心话题进行了一些梳理，主要都是集中在关于面向对象的思想方面。我通过部分故事的思路，结合生活来理解了关于面向对象的一些问题。如果需要可以回看我文章列表的中的文章。今天的部分比较零散，我的思考可能也有限，很多部分我的思考也不够，不足以用故事来涵盖，但是既然是个故事狗，那么还是来说一下，类型到底是干什么用的。
但是C++的内容非常庞大，之前也仅仅是冰山的一角，还有非常丰富的知识有待梳理。
在梳理今天内容的之前，我想先简单说明一下关于类型的概念，为什么计算机系统中需要设计变量类型呢？如果你熟悉JavaScript，那么在其中声明变量直接使用var xxx就行了，而在Python中，甚至连具体的类型名称都不用写！岂不是快哉？！省下了大量的力气来讨论变量类型，如果在c++11 之前，auto关键字还不能用于自动声明变量类型的时候，C++对于变量类型的要求可谓是相当的严格了。
那么咱们就先来说说，为什么需要有变量类型这件事吧。

• 变量类型的作用
  这个需要从非常原始的话题开始说起了~~~~原始到要存二进制开始说起。。。
  其实我们都知道，计算机，之所以叫做计算机，是因为他只能通过计算数字（真的就是计算数字，连数学都算不上。。。），而且为了方便计算机系统设计和实现，采用的是我们基本上很难读懂的二进制来计算我们想要的结果的。二进制很方便的表明了电的状态。但是，对于二进制来说，我们基本没办法直接读懂到底其中在说啥（就算能读懂，也记不住，可以参考一个智力比赛记灯泡的开关（个人觉得这个比赛丧心病狂，在此不吐槽了）。。。。）。他的最根本的优点也十分突出， 那就是简单（简单到只有两个数） 但随之而来的缺点也很明显，那就是他实在太长了。比如一个很简单的236使用二进制表示却成了1110 1100（幸好我还很用心的添加了空格<实际怕自己写错被打脸>），而这些我们很难直接读懂的东西会连续的写在一起，像‭0011 1001 0110 1100 1010‬这样，那么我们就很那区分出来，这到底是我们日常中熟悉的235210还是57 和 869等等等等。因为这牵扯到我上篇文章讲的那个钥匙和箱子的故事，也就是我们并不能通过数字来判断，多少个单位能够算作一组，这一组能够表达一个想要的数字。那这个时候，再拿出之前的故事，想知道箱子里面放的啥，那在箱子上贴上名字就行啦。其实类型相当于这个标签，在连续的二进制数字的序列中，就可以轻松知道，这个变量占有多大的内存。
  因此，类型声明，其实是为了告诉编一起，我这个变量需要多大的内存空间，比如int一般为4个字节，编译器可以非常方便的按照大小取出全部的数据来了。那么为什么C/C++对于内存这么关注，而Python这类语言不关注呢？其实，对于python这类解释形语言来说，在他和内存之间其实还有一个东西叫做虚拟机，他主要负责控制变量的类型计算，而不需要Python亲力亲为来控制变量的类型了。（其实也就是把类型控制的部分抽出来了，不代表他没有类型，不然Python中不会有type()内置函数了）
  那么C/C++的类型如此重要，会不会牵扯到一个问题呢，那就是类型转换的问题了。

  转换函数

• 转为其它类型（Conversion function）

  //定义class Fraction{public:  Fraction(int num, int den = 1) :m_numerator(num), m_denminator(den){}  //定义转换函数  //可以告诉编译器，可以将Fraction转换为double  operator deouble() const   {       if(m_denominator)          return (double) (m_numerator / m_denominator) ;      else          return 1.0;  }private:  int m_numerator;  int m_denominator;};

  //使用Fraction f(3, 5);double d = 4 + f;  //调用operator double() 将f转为0.6，再进行运算//编译器会先查看是否存在`double operator+(int, Fraction)`的函数声明，如果该函数存在，则使用操作符重载//如果操作符重载不存在，编译器会查找是否存在Fraction想double的转换函数

  • 语法：

    operator targetType() const{   return statement; }

  • 转换函数的功能
    • 可以通过该函数告诉编译器，可以将自己转换为某一个类型
  • 转换函数的注意事项
    • 不需要参数
    • 不需要返回类型
    • 返回值需要考虑是否为const的问题
• 其它类型转为自己的类型（non-explicit-one-argument constructor）

  //定义class Fraction{public:  //non-explicit-one-argument constructor  //构造函数中部分有默认值，构造时，不需要传递全部参数，只要一个实参就可以  Fraction(int num, int den = 1)  : 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+（该函数按照上方定义得知，需要Fraction+Fraction）

• 语法

  • 按照正常构造方法，但在形参列表处，需要对不需要的参数写入默认值，最后只留下一个形参需要外部传入即可构造对象，该构造函数，可以将其他类型转化为需要的类型

• explicit关键字

  • 提出问题

    //定义class Fraction{public:  //non-explicit-one-argument constructor  //构造函数中部分有默认值，构造时，不需要传递全部参数，只要一个实参就可以  Fraction(int num, int den = 1)  : m_numerator(num), m_denominator(den) {}  Fraction operator+(const Fraction& f)  {      return Fraction(....);  }  operator double() const   {     if(m_denominator)        return (double) (m_numerator / m_denominator) ;      else        return 1.0;  }private:  int m_numerator;  int m_denominator;};

    //调用Fraction f(3, 5);Fraction d2 = f + 4; // [ERROR]Ambiguous//符合语法，但是此处存在二义性，运行时异常//语义一：转换函数，编译器可以将f转换为double，再执行加法运算//语义二：存在non-explicit-one-argument constructor，所以编译器也可以将常数4构造为Fraction，再进行加法运算。//由于以上两种方案，都可以实现该条语句的调用，所以编译器产生二义性，不能选择，随报错。

  • explicit的用法

    • 仅使用在构造函数处

    • 告诉编译器，该构造函数，仅用于调用，不能用于转换构造使用

      explicit Fraction(int num, int den = 1): m_numerator(num), m_denominator(den) {  }

智能指针（pointer-like classes）

//定义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->method();//实际通过智能指针返回了Foo的指针//让对象sp，也具有了指针一样的使用方法//关于->符号，有一个特殊行为，当作用下去后，得到对象后，不会被消耗掉

• 智能指针中一定持有一个真正的指针

仿函数（function-like classes）：重载()操作符

/定义部分template <class T>struct identity{    const T&;    operator() (const T& x) const { return x; }};template <class Pair>struct select1st{    const typename Pair::first_type& operator()(const Pair& x) const     {        return x.first;    }};template <class Pair>struct select2nd{    const typename Pair::second_type& operator()(const Pair& x) const     {        return x.second;    }}

//pair部分template <class T1, class T2>struct pair{    T1 first;    T2 second;    pair(): first(T1()), second(T2()){}    pair(const T1& a, const T2& b)      :first(a), second(b){}}

//使用部分select1st <pair>() ();//第一个括号：创建对象//第二个括号：调用操作符()重载

namespace

• 通过namespace可以将部分内容区分开，不需要考虑多人协作时，类、函数名称冲突的情况，只需要自己将自己的代码用namespace包起来即可

  .....//定义namespacenamespace storyDog{   ......  void function1(){....}   ......}.....

  ......//使用storyDog::function1();......

模版

• 类模版（class template）

  //定义部分template <typename T>class complex{public:  complex(T r = 0, T i = 0):re(r), im(i){}  complex& operator += (const complex&);  T real() const { return re; }  T imag() const { return im; }private:  T re, im;}

  {//使用的时候指定T的类型complex<double> c1(2.5, 1.5);complex<int> c2(c2, 6);}

• 函数模版（function template）

  //定义template <class T>inline const T& min(const T& a, const T& b){    return b < a? b: a;}

  class stone{public:  stone(int w, int h, int weight):_w(w), _h(h), _weight(weight){}  bool operator< (const stont rhs) const  {      return _weight < rhs._weight;  }private:  int _w, _h, _weight;}//使用stone r1(2, 3), r2(3, 3);r3 = min(r1, r2);//编译器会对function template进行实参推倒（argument deduction），无需手动指定具体类型是什么。

• 成员模版（member template）

  template <class T1, class T2>struct pair{  typedef T1 first_type;  typedef T2 second_type;  T1 first;  T2 second;  pair():first(T1()), second(T2()){}  pair(const T1& a, const T2& b):first(a),second(b){}  //成员模版（在模版中的模版）  //可以更细微的使用模版，不需要与类模版相同  template<class U1, class U2>  pair(const pair<U1, U2>& p):first(p.first), second(p. second){}}

  • 考虑带有子父类模版的情况

    template<typename _Tp>class share_ptr:public __shared_ptr<_Tp>{  ...  template<typename _Tp1>  explicit shared_ptr(_Tp1* __p)      : __shared_ptr<_Tp>(__p){}  ...};

      Base1* ptr = new Derived1; //up-cast  shared_ptr<Base1> sptr(new Derived1);  //模版up-cast

• 模版特化（Specialization）

  //泛化的版本template<class key>struct hash();

  //特化的版本template<>struct hash<long>{  size_t operator()(long x) const { return x;}};

  cout << hash<long>()(1000);

• 模版的偏特化（partial specialization）
  • 个数上的偏特化

    template<typename T, typename Alloc=...>class vector{....}....template <typename Alloc = ....>//绑定了其中的一个，另外一个没有被特化class vector<bool, Alloc>{....}

  • 范围的偏特化

    //非指针用这套代码template<typename T>class C{....};//指针用这套代码template <typename T>class C<T*>{....};

• 模版模版参数（template template parameter）

  //定义template<typename T,     template <typename T>      class Container>//含义：第二个模版接受一个Container//并且，这个Container的模版接受第一模版参数作为他的模版参数class XCls{private:   Container<T> c;public:    ....};

  //使用template<typename T>using Lst = list<T, allocator<T>>;XCls<string, Lst> mylst;

  浅谈C++11

• 可变数量的模版参数（variadic templates）

  void print(){}//定义template<typename T, typename... Types>void print(const T& firstArg, const Types&... args) { cout << firstArg << endl; print(args...);//递归调用，来解析模版参数包}.......{   //调用 print(7.5, "hello", bitset<16>(377), 42);//想要知道后续的参数包的大小，可以使用sizeof...(args)来获得}

• auto关键字

  list<string> c;auto ite = find(c.begin(), e.end(), target);//通过auto来声明变量类型//原始的是list<string>::iterator ite;现在简化为auto即可。

  注意：使用auto声明变量，必须初始化，否则会报错。

• ranged-base for
  • 对于可以遍历的对象，可以简化的来写for循环

    for(decl :coll){    statement}

  • pass by value(不会影响原始容器的值)

    vector<double> vec;for(auto elem: vec){cout << elem << endl;}

  • pass by reference(可以改变原始容器的内容)

    vector<double> vec;for(auto& elem: vec){elem += 3;//可以改变原容器的内容}

    reference

    引用（reference）：就是对象的另一个名字。（名字是名词，所以此时我们把引用当做一个名词）。引用主要用作函数的形式参数。（作为参数的，那更是名词了）。到此为止，接下来就好理解了，因为它是个名词，对于名词的理解就比动词的理解方便多了。
    进一步理解：引用是一种复合类型（引用又是一种类型），通过在变量名前添加”&“符号来定义。复合类型指的是用其他类型来定义的类型。
    结论：其实引用只是一个别名，即只是他绑定的对象的另一个名字，作用在引用上的所有操作事实上都是作用在该引用绑定的对象上

关于面向对象的问题

关于这个问题啊，我之前的笔记写的很详细，在这里也不想再赘述了。链接：
http://www.jianshu.com/p/34a30505176d