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

字数 2031阅读 51

之前几次,对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包起来即可
.....
//定义namespace
namespace 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

推荐阅读更多精彩内容