c++基于对象的编程风格

知识点：
下面知识点会在代码中统一演示
1.构造函数和析构函数（构造函数的初始化语法 直接初始化和成员初始化列表）
2.mutable和const
1)为了保证成员函数在调用时不会更改其调用者，必须在member function 身上标注const。
2)如果数据成员不属于抽象概念的一环，改变此成员不算改变class object，那么要加上mutable标注，之后改变只此成员的函数也可以标注const。
3.this指针在member function 内来指向其调用者。
4.静态类成员
1)静态类数据成员表示唯一的、可共享的member，可以在同一类所有对象中被调用。
2)静态类成员函数member function不访问任何 no-static member的条件下才能够被声明为static,此函数可以在调用时独立使用不需要靠任何对象 Triangular::is_elem()

#include<vector>
#include<iostream>
using namespace std;

class Trianglar
{
public:
    Trianglar(int len,int beg_pos);
    Trianglar( const Trianglar &rhs );
    ~Trianglar();
    int length() const{return _length;}
    int beg_pos() const{return _beg_pos;}
    int elem(int pos) const;
    bool next(int &val) const;
    void next_reset() const {_next = _beg_pos - 1 ;}
    Trianglar& operator =(const Trianglar rhs);

    static void display(int length,int beg_pos,ostream &os);
    static void gen_elements( int length );
private:
    int _length;
    int _beg_pos;  //起始位置
    mutable int _next;     //下一个迭代目标此值所作的改变不会改变class object的常量性
    enum { _max_elems = 1024 };

    static vector<int> _elems;  //静态数据成员此类的所有对象共享

};

Trianglar::Trianglar(int len,int beg_pos = 1)
    :_length(len > 0 ? len : 1),
    _beg_pos(beg_pos > 0 ? beg_pos : 1)
{
    _next = _beg_pos - 1;
    int elem_cnt = _beg_pos + _length;
    if( _elems.size() < elem_cnt )
        gen_elements(elem_cnt);
}
Trianglar::Trianglar( const Trianglar &rhs )
    : _length ( rhs._length  ),
      _beg_pos( rhs._beg_pos ),     
      _next( rhs._next )
{} 
Trianglar& Trianglar::operator =(const Trianglar rhs)
{
    if(this != &rhs )
    {
        _beg_pos = rhs._beg_pos;
        _length = rhs._length;
        _next = _beg_pos - 1;
    }
    return *this;
}
Trianglar::~Trianglar()
{
}
bool Trianglar::next(int &val) const
{
    if(_next < _beg_pos + _length)
    {
       val = _elems[_next++];
       return true;
    }
    return false;
}

int Trianglar::elem(int pos) const
{
    if(pos < _beg_pos + _length)
        return _elems[pos];
    return 0;
}

void Trianglar::display(int length,int beg_pos,ostream &os)
{
    if(length <= 0 || beg_pos <= 0)
    {
        cerr << "invalid parameters -- unable to fulfill request: "
              << length << ", " << beg_pos << endl;
        return;
    }
    int elems = beg_pos + length - 1;
    for(int ix = beg_pos - 1;ix < elems;++ ix)
        os<<_elems[ix]<<' ';
}
ostream& operator<<(ostream &os,Trianglar &rhs)
{
    os<< "( " << rhs.beg_pos() << " , " << rhs.length()<<" ) ";
    rhs.display(rhs.length(),rhs.beg_pos(),os);

    return os;
}

void Trianglar::gen_elements( int length )
{
    if ( length < 0 || length > _max_elems ){
        cerr << "Triangular Sequence: oops: invalid size: "
             << length << " -- max size is "
             << _max_elems << endl;
        return;
    }

    if ( _elems.size() < length )
    {
        int ix = _elems.size() ? _elems.size()+1 : 1;
        for ( ; ix <= length; ++ix )
              _elems.push_back( ix*(ix+1)/2 );
    }
}
int sum(const Trianglar &trian)      //const reference 不能调用公开接口中的non_const成分即trian调用的函数
                                     //必须全部为const函数
{
    if(!trian.length())
        return 0;
    int val,sum=0;
    trian.next_reset();
    while(trian.next(val))
    {
        sum += val;
    }
    return sum;
}

//验证:
#include<iostream>
#include<vector>
#include"Trianglar.h"

using namespace std;
vector<int> Trianglar::_elems;                 //静态数据成员在在对象定义前必须定义完成
int main()
{
    Trianglar trian(4);
    cout<<trian<<"--sum :"<<sum(trian)<<endl;
    Trianglar trian1(4,3);
    cout<<trian1<<"--sum :"<<sum(trian1)<<endl;
    return 0;
}

“`