《Essential C++》读书笔记 之 基于对象编程风格

《Essential C++》读书笔记 之 基于对象编程风格

2014-07-13

4.1 如何实现一个class

4.2 什么是Constructors（构造函数）和Destructors（析构函数）

  Constructor

    Member Initialization List（成员初值表）

  Destructor

    Memberwise initialization（成员逐一初始化）

4.3 何谓mutable（可变）和const（不变）

  Mutable Data Member（可变的数据成员）

4.4 什么是this指针

4.5 Static Class Member（静态的类成员） 

4.6 打造一个Iterator Class

  嵌套型别（Nested Types）

4.7 合作关系必须建立在友谊的基础上

4.8 实现一个copy assignment operator

4.9 实现一个fuction object

4.11 指针：指向Class Member Functions

4.1 如何实现一个class

---

 返回

class定义由两部分组成：class的声明，以及紧接在声明之后的主体。主体部分由一对大括号括住，并以分号结尾。

主体内的两个关键词public和private。public members可以在程序的任何地方被取用，private members只能在member function或class friend内被取用。

以下是stack class的起始定义：

class Stack {
public:     
    bool   push( const string& );
    bool   pop(  string &elem );
    bool   peek( string &elem );

    bool   empty();
    bool   full();

       //size()定义于class本身内，其它members则仅仅只是声明
    int    size() { return _stack.size(); }
private:
    vector<string> _stack;
};

以下是如何定义并使用Stack class object：

void fill_stack( Stack &stack, istream &is = cin )
{
    string str;
    while ( is >> str && ! stack.full() )
            stack.push( str );

    cout << "Read in " << stack.size() << " elements
";
}

所有member function都必须在class主体内进行声明。至于是否要同时进行定义，可自由决定义。

• 如果要在class主体内定义，这个member fuction会自动被视为inline函数。例如size()函数
• 如果要在class主体外定义，必须使用特殊语法，来分辨该函数究竟属于哪一个class。如果希望该函数为inline，应该在最前面指定关键字inline：

inline bool Stack::empty()
{
    return _stack.empty();
}

上述的： Stack::empty()

告诉编译器说，empty()是Stack class的一个member。class名称之后的两个冒号（Stack::）是所谓的class scope resolution（类范围决议）运算符。

• 对inline函数而言，定义于class主体内或主体外，并没有分别。class定义式及其inline member function通常会放在与class同名得头文件中。例如Stack class的定义和其empty()函数都放在Stack.h头文件中。
• non-inline member functions应该在程序代码中定义，该文件通常和class同名，其后接着扩展名.c，.cc，.cpp。

4.2 什么是Constructors（构造函数）和Destructors（析构函数）

---

 返回

Constructor

Constructor（构造函数）的作用是对data member进行初始化。

语法规定: costructors函数名称必须和class名称相同。constructor不应指定返回型别，亦不需返回值。它可以被重载。看以下代码：

class Triangular
{
public:
    //一组重载constructors
    Triangular(); //default constructors
    Triangular(int lin);
    Triangular(int len, int beg_pos);
private:
    int _length;  //元素数目
    int _beg_pos; //起始位置
    int _next;    //下一个迭代目标
}

如何调用构造函数：

    //对t施行default constructor(无参构造函数)
    Triangular t;
    //调用戴两个参数的constructor
    Triangular t2(10,3);
    //是调用constructor or assignment operator呢？答案是constructor，调用戴一个参数的constructor
    Triangular t3=8;

    //该语句t5被定义为一个函数，其参数表为空，返回Triangular object。why？
    //因为C++必须兼容与C，对C而言，t5之后带有小括号，会被视为函数。
    Triangular t5();

对于默认函数，它不需要任何arguments。这意味着以下两种情况：

• 第一，它不接收任何参数：

Triangular::Triangular()
{
    int _length=1;
    int _beg_pos=1;
    int _next=0;
}

• 第二，它为每个参数提供了默认值：

class Triangular
{
public:
    //default constructors
    Triangular(int len=1, int beg_pos=1);    

Member Initialization List（成员初值表）

Constructor定义式的第二种初始化语法，是Member Initialization list：

Triangular::Triangular(const Triangular &rhs)
    : _length(rhs._length), _beg_pos(rhs._beg_pos),_next(rhs._next)
{}  //是的，空的

Member Initialization List的主要作用是将参数传递给member class object的constructor。假设重新定义Triangular，令它包含一个string member：

class Triangular
{
public:
    //...
private:
    string _name;
    int _length, _beg_pos, _next;
}

为了将_name的初值传给string constructor，必须以member intialization list完成。代码如下：

Triangular::Triangular(int len, int bp)
    : _name("Triangularr")
{
    _length=len>0?len:1;
    _beg_pos=bp>0?bp:1;
    _next=_beg_pos-1;
}

Destructor

和constructor对立的是destructor。所谓destructor是用户自行定义的一个class member。一旦某个class提供有destructor，当其object结束生命时，便会自动调用destructor处理善后。destructor主要用来释放在constructor中或对象生命周期中配置的资源。

语法规定：Destructors函数名称必须在class名称再加上‘~’前导符号。它绝对不会有返回值，也没有任何参数。正由于起参数表为空，所以也决不可能被重载（overloaded）。

考虑以下的Matrix class。其constructor使用new表达式从heap中配置double数组所需的空间；其destructor则负责释放这些内存：

class Matrix
{
public:
    Matrix(int row, int col):_row(row),_col(col)
    {
        //constructor进行资源配置
        _pmat=new double[row*col];
    }
    ~Matrix()
    {
        //destructor进行资源释放
        delete [] _pmat;
    }
private:
    int _row,_col;
    double* _pmat;
}

Memberwise initialization（成员逐一初始化）

默认情况下，当我们以某个class object作为另一个object的初值，class data members会被依次复制。但对Matrix class而言，default memberwise initialization并不恰当。看以下代码：

    //此处，constructor发生作用
    Matrix mat(4,4);  

    //此处，进行default memberwise initialization
    Matrix mat2=mat;
    //...这里使用mat2
    //此处，mat2的destructor发生作用

    //此处，mat的destructor发生作用

上述代码地5行，default membrewise initialziation会将mat2的_pmat设为_pmat值：

mat2._pmat=mat._pmat;

这会使得两个对象的_pmat都寻址到heap内的统一个数组。当Matrix destructor施行mat2身上是，该数组空间便被释放。不幸的是mat的_pmat仍然指向那个数组，而你知道，对空间以被释放的数组进行操作，是非常严重的错误行为。

如何避免这样的情况呢？本例中必须改变这种“成员逐一初始化”的行为模式。可以通过“为Matrix提供另一个copy constructor”达到目的。见如下代码：

Matrix::Matrix(const Matrix &rhs):_row(rhs._row),_col(rhs._col)
{
    //对rhx._pmat所寻址之叔祖产生一份完全副本
    int elem_cnt=_row*_col;
    _pmat=new double[elem_cnt];

    for(int ix=0;ix<elem_cnt; ++ix)
        _pmat[ix]=rhs._pmat[ix];
}

4.3 何谓mutable（可变）和const（不变）

---

  返回

看下面这个函数sum，它调用对象Triangular的member function:

int sum(const Triangular &trian)
{
    int beg_pos=trian.beg_pos();
    int length=trian.length();
    int sum=0;

    for(int ix=0;ix<length;++ix)
        sum+=trian.elem(beg_pos+ix);
    return sum;
}

trian是个const reference参数，因此，编译器必须保证trian在sum()之中不会被修改。但是，sum()所调用的每一个member funciton都有可能更动trian的值。为了确保trian的值不被更动，编译器必须保证beg_pos()，length()，elem()都不会更动其调用者。编译器如何得知这项信息呢？

class的设计这必须在member function身上标注const，以此告诉编译器：这个membr function不会更动class object的内容：

class Triangular
{
public:
    //一组重载constructors
    Triangular(); //default constructors
    Triangular(int lin);
    Triangular(int len, int beg_pos);

    //以下是const member fuctions
    int length()  const { return _length;  }
    int beg_pos() const { return _beg_pos; }
    int elem( int pos ) const;

    //以下是non-const member fuctions
    bool next( int &val ); 
    void next_reset() { _next = _beg_pos - 1; }
private:
    int _length;  //元素数目
    int _beg_pos; //起始位置
    int _next;    //下一个迭代目标

    //static data members将于4.5节说明
    static vector<int> _elems;
};

const修饰词紧接于函数参数表之后。凡在class主题外定义者，如果它是一个const member function，那必须同时在声明式与定时式都指定const。如下代码：

int Triangular::elem(int pos) const
{    return _elems[pos-1];}

 编译器会检查每个声明为const的member function，看看他们是否真的没有更动class object内容。如下代码：

bool Triangular::next(int &value) const
{
    if(_next<_beg_pos+_length-1)
    {
        //错误，更动了_next的值
        value=_elems[_next++];
        return true;
    }
    return false;
}

注意：编译器能够区分const版本和non-const版本的函数。如下代码：

class val_class
{
public:
    val_class(const BigClass &v):_val(v){}
    const BigClass& val() const{return _val;}
    BigClass& val() {return _val;}
private:
    BigClass _val;
};
class BigClass{};

在调用时，const class object会调用const版的val()（那就不可能改变对象的内容了）。non-const class object会调用non-const版的val()。如下代码：

void exmpale(const val_class *pbc, val_class &rbc)
{
    pbc->val(); //这会调用const版本
    rbc.val();  //这会调用non-const版本
}

Mutable Data Member（可变的数据成员）

以下是函数sum()的另一种做法，用next()和next_reset()两个member function对trian元素进行迭代：

int sum(const Triangular &trian)
{
    if(!trian.length())
        return 0;
    int val,sum=0;
    //Compile error
    trian.next_reset();
    //Compile error
    while(trian.next(val))
        sum+=val;
    return sum;
}

上述代码会编译出错。因为trian是个const object，而next()和next_reset()都会更懂_next的值，它们都不是const member function。但他们被train调用，于是造成错误。

于是我们想是否把next()和next_reset()改为const。但它们确实是改变了_next的值呀！

这里，我们要重新认识一下，在class的data member中，哪些应限定为常数性（constness），哪些不是：

• _length和_beg_pos提供了数列的抽象属性。如果我们改变了它们，形同改变了其性质，和未改变的状态不再相同。所以它们应限定为常数性；
• _next只是用来让我们得以实现除iterator机制，它本身不属于数列抽象概念的一环。改变_next的值，从意义上来说，不能视为改变class object的状态，或者说不算破坏了对象的常数性。 

只要将_next标识为mutable，我们就可以宣传：对_next所作的改变并不会破坏class object的常数性： 

class Triangular
{
public:
    //添加const
    bool next( int &val ) const;
    void next_reset() const { _next = _beg_pos - 1; }
    //...
private:
    //添加mutable
    mutable int _next;    //下一个迭代目标
    int _length;  
    int _beg_pos;
};

现在，next()和next_reset()既可以修改_next的值，又可以被声明为const member functions。

4.4 什么是this指针

---

  返回

我们得设计一个copy()成员对象，才能够以Triangular class object作为另一个Triangular class object的初值。假设有以下两个对象，将其中一个拷贝给另一个：

    Triangular tr1(8);
    Triangular tr1(8,9);

    ////将tr2拷贝给tr1
    tr1.copy(tr2);

函数copy()的实现：

Triangular& Triangular::copy(const Triangular &rhs)
{
    _length=ths._length;
    _beg_pos=rhs._beg_pos;
    _next=rhs._beg_pos-1;

    retrun *this;  //什么是this指针
};

其中rhs（right hand side的缩写）被绑定至tr2。而赋值操作中，_length寻址至tr1内的相应成员。这里出现一个问题：如何寻址至tr1对象本身？this指针就是扮演这样的角色。

本例中，this指向tr1。这是如何作到的？内部的过程是，编译器自动将指针夹道每一个member functions的参数表中，于是copy()被转换为以下形式：

//伪码（pseudo code）:member function被转换后的结果
Triangular& Triangular::copy(Triangular *this, const Triangular &rhs)
{
    this->_length=ths._length;
    this->_beg_pos=rhs._beg_pos;
    this->_next=rhs._beg_pos-1;

    retrun *this;  //什么是this指针
};

 4.5 Static Class Member（静态的类成员） 

---

  返回

注意：member functions只有在“不存取任何non-static members”的条件下才能够被声明为static，声明方式是在声明式之前加上关键词static：

class Triangular
{
public:
    static bool is_elem(int);
    //...
private:    
    static vector<int> _elems;
    //...
};

当我们在class主体外部进行member fuctions的定义时，不许要重复加上关键词static。

4.6 打造一个Iteator Class

---

  返回

定义运算符：运算符函数看起来很像普通函数，唯一的差别是它不需指定名称，只需在运算符符号之前加上关键词operator即可。如class Triangular_iterator:

class Triangular_iterator
{
public:
    //为了不要在每次存取元素时都执行-1操作，此处将_index的值设为index-1
    Triangular_iterator( int index ) : _index( index-1 ){} 

    bool operator==( const Triangular_iterator& ) const;
    bool operator!=( const Triangular_iterator& ) const;
    int  operator*() const;
    Triangular_iterator& operator++();       //前置（prefix）版
    Triangular_iterator  operator++( int );  //后置（prefix）版

private:
    void check_integrity() const;  
    int _index;
};

Triangular_iterator维护一个索引值，用以索引Triangular中用来存储数列元素的那个static data member，也就是_elems。为了达到这个目的，Triangular必须赋予Triangular_iterator member functions特殊的存取权限。我们会在4.7节看到如何通过friend机制给予这种特殊权限。

如果两个Triangular_iterator对象的_idex相等，我们边说这两个对象相等：

inline bool Triangular_iterator::
operator==( const Triangular_iterator &rhs ) const
          { return _index == rhs._index; }

运算符的定义方式：

• 可以像member functions一样：

inline int Triangular_iterator::
operator*() const
{
    check_integrity();
    return Triangular::_elems[ _index ]; 
}

• 也可以像non_member functions一样：

inline int operator*(const Triangular_iterator &rhs) 
{
    rhs.check_integrity();
    //注意：如果这是个non-member function，就不具有取用non-public members的权利
    return Triangular::_elems[ _index ]; 
}

non-member运算符的参数列中，一定会比相应的member运算符多一个参数，也就是this指针。

嵌套型别（Nested Types）

typedef可以为某个型别设定另一个不同的名称。其通用形式为：

typedef existing_type new_name

其中existing_type可以是人翮一个内建型别、复合型别，或class型别。

下面一个例子，另iterator等同于Triangular_iterator ，以简化其使用形式：

Triangular::iterator it = trian.begin();

上述代码的Triangular::告诉编译器，在Triangular内部检视iterator。

可以将iterator嵌套置于每个“提供iterator抽象观念”的class内。

4.7 合作关系必须建立在友谊的基础上 

---

  返回

以下代码的non-member operator*()会直接取用Triangular的private member：why？ 

inline int operator*(const Triangular_iterator &rhs) 
{
    rhs.check_integrity();   //直接取用private member
    return Triangular::_elems[ _index ];  //直接取用private member
}

因为任何class都可以将其它的functions或classes指定为友元（friend）。所谓friend，具备类于class member function相同的存取权限。为了让operator*()通过编译，不论Triangular或Triangular_iterator都必须将operator*()声明为“友元”：

class Triangular
{
    friend int operator*(const Triangular_iterator &rhs);
    //...
}
class Triangular_iterator
{
    friend int operator*(const Triangular_iterator &rhs);
    //...
}

只要将某个函数的原型（prototype）之前加上关键词friend，就可以将它声明为某个class的friend。这份声明可以出现在class定义式的任何位置上，不受private和public的影响。

如果你希望将某个重载函数 声明为某个class的friend，你必须明白的为这个函数加上关键词friend。比如：Triangular_iterator内的operator*()需要直接取用Triangular的private members，就需要将它声明为Triangular的friend:

class Triangular
{
    friend int Triangular_iterator::operator*();
    //...

这样，编译器就知道它是Triangular_iterator的member function。

也可以令class A与class B建立friend关系，让class A的所有member functions都成为class B的friend。如下代码：

注意：友谊关系的建立，通常是为了效率的考虑。如果我们仅仅只是希望进行某个data member的读写，那么，为它提供具有public存取前线的inline函数即可。

class Triangular
{
    friend class Trianguar_iterator;
    //...

 4.8 实现一个copy assignment operator

---

  返回

默认情况下，当我们将某个class object赋值给另一个，像这样：

Triangular tril(8), tri2(8,9);
tri1 = tri2;

class data members会被依次赋值过去。辄被称为default memberwise copy。但对于4.2节的Matrix class，这种default memberwise copy行为便不正确。

Matrix需要一个copy constructor和一个copy assignment operator。以下便是我们为Matrix的copy assignment operator所做的定义：

Matrix& Matrix::
    operator=(const Matrix &rhs)
{
    if(this!=&rhs)
    {
        _row=rhs._row; _col=rhs._col;
        int elem_cnt=_row*_col;
        delete [] _pmat;
        _pmat=new double[elem_cnt];
            
        for(int ix=0;ix<elem_cnt; ++ix)
            _pmat[ix]=rhs._pmat[ix];
    }
    return *this;
}

4.9 实现一个fuction object

---

  返回

我们已经在3.6节看到了标准程序库定义的function objects。本节教你如何实现自己的function object。

所谓functon object乃是一种“提供有function call运算符”的class。

当编译器在编译过程中遇到函数调用，例如：

lt(ival);

时，lt可能是函数名称，可能是函数指针，也可能是提供了function call运算符的function object。如果是function object，编译器会在内部将此语句转换为：

lt.operator(ival);

现在我们实现一个function call运算符，测试传入值是否小于某个指定指。我们将此class命名为LessThan:

class LessThan
{
public:
    LessThan(int val):_val(val){}
    int comp_val()const {return _val;}   //基值的读取
    void comp_val(int nval) {_val=nval;} //基值的写入

    bool operator()(int _value)const;
private:
    int _val;
};

其中的function call运算符实现如下：

inline bool LessThan::operator()(int value)const{return value<_val;}

定义和调用function call运算符：

int count_less_than(const vector<int>&vec,int comp)
{
    LessThan lt(comp);
    int count=0;
    for(int ix=0;ix<vec.size();++ix)
        if(lt(vec[ix]))
            ++count;
    return count;
}

通常我们会把function object当作参数传给泛型算法，例如：

void print_less_than(const vector<int>&vec,int comp, ostream &os=cout)
{
    LessThan lt(comp);
    vector<int>::const_iterator iter=vec.begin();
    vector<int>::const_iterator it_end=vec.end();

    os<<"elements less than"<<lt.comp_val()<<endl;
    while((iter=find_if(iter,it_end,lt))!=it_end)
    {
        os<<*iter<<' ';
        ++iter;
    }
}

4.11 指针：指向Class Member Functions 

---

  返回

pointer to member function（指向成员函数之指针）机制的运用 ，这种指针看起来和pointer to non-member function（2.8节介绍过）极为相似。两者皆必须制定其返回型别和参数表。不过，pointer to member function还得指定它所指出的究竟是哪一个class。例如：

void (num_sequence::*pm)(int)=0;

便是将pm声明为一个指针，指向num_sequence's member function，后者的返回型别必须是void，且只接受单一参数，参数型别为int。pm的初始值为0，表示它当前并不指向任何member function。
如果觉得上述语法过于复杂，我们可以通过typedef加以简化。如下代码：

typedef void(num_sequence::*PtrType)(int);
PtrType pm=0;

pointer to member function和pointer to function的一个不同点是：前者必须通过同类对象加以调用，而该对象便是此member function内的this指针所指之物：

num_sequence ns;
typedef void(num_sequence::*PtrType)(int);
PtrType pm=&num_sequence::fibonaaci;

//以下写法和ns.fibonaaci(pos)相同
(ns.*pm)(pos)

其中的.*符号是个“pointer to member selection运算符”，系针对class object运行。

至于针对pointer to class object运行的“pointer to member selection运算符”，其符号是->*：

num_sequence *pns=&ns

//以下写法和pns->Fibonacci(pos)相同
(pns->*pm)(pos)