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
4000
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;
}

“`