《Essential C++》读书笔记之面向过程编程风格

2014-06-18

2.2 调用（invoking）一个函数

2.2.1 Pass by Reference语义

在函数swap的参数中使用reference和pointer

pointer参数和reference参数的差异和用法

2.4 使用局部静态对象（Local Static Objects）

2.5 声明一个inline函数

2.7 定义并使用Template Functions （模板函数）

2.8 函数指针（Pointers to Functions）带来更大的弹性

函数指针和指针函数区别

2.9 设定头文件（Header Fiels）

2.2 调用（invoking）一个函数

2.2.1 Pass by Reference语义

reference扮演着外界与对象之间的一个间接号码牌的角色。只要在型别名称和reference名称之间插入&符号，便声明了一个reference:

 #include <iostream>

 using namespace std;

 int main()

 {

     int ival=;  //对象，型别为int

     int *pi=&ival;  //pointer（指针）,指向一个int对象

     int &rval=ival; //reference（化身），代表一个int对象

     //这里不是令rval改为代表jval对象，而是将jval赋值给rval所代表的对象（也就是ival）。

     int jval=;

     rval=jval;

     ival =;

     pi;

     //这里不是令pi指向rval对象，而是将ival（此为rval所代表之对象)的地址赋给pi

     pi=&rval;

     return ;

 }

《Essential C++》读书笔记之面向过程编程风格-LMLPHP

重点是：面对reference的所有操作都像面对“reference所代表的对象”所进行的操作一样。

在函数swap的参数中使用reference和pointer

当我们以reference作为函数参数时，情况是一样的，如下代码所示：

 #include <iostream>

 void swap(int &, int &);

 int main()

 {

     int v1=;

     int v2=;

     swap(v1,v2);

     v1;

     v2;

     return ;

 }

 void swap(int &val1, int &val2)

 {

     int temp=val1;

     val1=val2;

     val2=temp;

 }

运行结果如下图所示：

《Essential C++》读书笔记之面向过程编程风格-LMLPHP

将参数声明为reference的理由有两个：

希望直接对所传入的对象进行修改；
为了降低复制大型对象的负担。

如果我们愿意，也可以将参数以pointer形式传递。这和以reference传递的效用相同：传递的是对象地址，而不是整个对象的复制品。唯一的差别是他们的用法不同。如下代码所示：

 #include <iostream>

 void swap(int *,int *);

 int main()

 {

     int v1=;

     int v2=;

     swap(&v1,&v2);

     v1;

     v2;

     return ;

 }

 void swap(int *val1, int *val2)

 {

     int temp=*val1;

     *val1=*val2;

     *val2=temp;

 }

但如果swap方法改成如下，变量v1,v2不会调换：

 void swap(int *val1, int *val2)

 {

     int *temp=val1;

     val1=val2;

     val2=temp;

 }

因为上述方法只是更改了指针本身的地址，如下图：

《Essential C++》读书笔记之面向过程编程风格-LMLPHP

pointer参数和reference参数的差异和用法

pointer可能（也可能不）指向一个实际对象。当我门提领pointer时，一定要先确定其值并非为0。至于reference则必定会代表某个对象。

一般来说，除非你希望在函数内更改参数值，否则建议传递内建型别时，不要使用传址的方式。传址机制主要是作为传递class objects之用。

2.4 使用局部静态对象（Local Static Objects）

fibon_seq()函数是这样一个函数，每次调用时，会计算出Fibonacci数列（元数数目由用户指定），并以一个vector存储计算出来的元素值，然后返回。代码如下：

 vector<int> fibon_seq( int size )

 {

    if ( size <=  || size >  )

    {

         cerr << "Warning: fibon_seq(): "

              << size << " not supported -- resetting to 8\n";

           size = ;

     }

    vector<int> elems( size );

    for ( int ix = ; ix < size; ++ix )

            if ( ix ==  || ix ==  )

                   elems[ ix ] =  ;

             else elems[ ix ] =  elems[ix-] + elems[ix-];

    return elems;

 }

以上代码有一个问题：每次调用时，都要重新计算。
我们希望，保存已经计算出来的元素。上面代码的局部变量肯定不行。如果将vector对象定义于file scope之中，又过于冒险，它会打乱不同函数之间的独立性，使它们难以理解。

本例的另一个解法便是使用局部静态对象：

 #include <iostream>

 #include <string>

 #include<vector>

 using namespace std;

 //定义函数

 const vector<int> *fibon_seq( int);

 int main()

 {

     fibon_seq(  );

     fibon_seq(  );  //前4个element都已计算，不会重复计算

     fibon_seq(  );  //只计算还没有计算出来的第6个element

     return ;

 }

 const vector<int> *fibon_seq( int size )

 {

     const int max_size = ;

     static vector< int > elems;

     if ( size <=  || size > max_size ){

         cerr << "fibon_seq(): oops: invalid size: "

             << size << " -- can’t fulfill request.\n";

         return ;

     }

     // if size is equal to or greater than elems.size(),

     // no calculations are necessary ...

     for ( int ix = elems.size(); ix < size; ++ix ){

         if ( ix ==  || ix ==  )

             elems.push_back(  );

         else elems.push_back( elems[ix-]+elems[ix-] );

     }

     return &elems;

 }

2.5 声明一个inline函数

回想一下,fibon_elem()返回一个Fibonacci数列元素，其位置由用户指定。在最初的版本中，每次调用，它都会重新计算每一个数列元素，直到用户指定的位置位置。它会检验用户所指定的位置是否合理。

为了使这个函数更容易理解，我们可以将各个小工作分解为独立函数，以求更简化：

 bool is_size_ok(int size)

 {

     const int max_size=;

     if(size<=||size>max_size)

     {

         cerr<<"Oops: requested size is not supported: "

             <<size

             <<" --can't fulfill request.\n";

         return false;

     }

     return true;

 }

 //计算Fibonacci数列中的size个元素

 const vector<int>* fibon_seq(int size)

 {

     static vector<int> elems;

     if(!is_size_ok(size))

         return ;

     for(int ix=elems.size();ix<size;++ix)

     {

         if(ix==||ix==)

             elems.push_back();

         else elems.push_back(elems[ix-]+elems[ix-]);

     }

     return &elems;

 }

 //返回Fibonaci数列中位置为pos的元素

 bool fibon_elem(int pos,int &elem)

 {

     const vector<int> *pseq=fibon_seq(pos);

     if(!pseq)

     {

         elem=;

         return false;

     }

     elem=(*pseq)[pos-];

     return true;

 }

但是，先前的做法中，fibon_elem()只须调用一个函数便可完成所有运算，如今必须动用3个函数。这成了它的缺点。这项负担是否很重要呢？这和应用时的形势有关。如果其执行效能不符合理想，只能在将3个函数重新组合成一个。

然而C++还提供了另一个解决方法，就是将这些函数声明为inline。

将函数声明为inline，表示要求编译器在每个函数调用点上，将函数的内容展开。面对一个inline函数，编译器可将该函数的调用操作改为一份函数代码副本取而代之。只要在函数前面加上关键字inline即可：

 //ok:现在fibon_elem()成了inline函数

 inline bool fibon_elem(int pos,int &elem)

 {

     /*函数定义与先前版本相同*/

 }

注意：将函数指定为inline，只是对编译器提出一种要求而没有强制性，具体分析，请参考7.1.1节

inline函数的定义常常被置于头文件中。由于编译器必须在它被调用的时候加以展开，所有这个时候起定义必须是有效的，2.9节有更深入的讨论。

2.7 定义并使用Template Functions （模板函数）

假设有3个diplay_messaeg()函数，分别用以处理元数型别为int、double、string的3中vectors:

 void display_message(const string&, const vector<int>&);

 void display_message(const string&, const vector<double>&);

 void display_message(const string&, const vector<string>&);

我们在假设他们的函数主体也很相似，唯一的差别仅在于第二个参数的型别。
这样的情况很多，C++提供一种机制，函数模板（function template），将参数表中指定的参数的型别信息抽离出来。

 #include <iostream>

 #include <string>

 #include<vector>

 using namespace std;

 //在mian()之前，就不用声明函数了

 template <typename elemType>

 void display_message(const string &msg, const vector<elemType> &vec )

 {

     cout<<msg;

     for ( int ix = ; ix < vec.size(); ++ix )

     {

         elemType t =vec[ix];

         cout<<t

             <<' ';

     }

 }

 int main()

 {

     string iMsg="show int vector: ";

     int iArr[]={,,};

     vector<int> iVec(iArr,iArr+);

     display_message(iMsg,iVec);

     cout<<'\n';

     string cMsg="show char vector: ";

     char cArr[]={'a','b','c'};

     vector<char> cVec(cArr,cArr+);

     display_message(cMsg,cVec);

     return ;

 }

2.8 函数指针（Pointers to Functions）带来更大的弹性

假设有一个函数"fibon_elem()"要返回fibon数列指定位置的元素：

 bool fibon_elem( int pos, int &elem )

 {

     const vector<int> *pseq=fibon_seq(pos);   //(A)

     if(!pseq)

     {

         elem=;

     return false;

     }

     elem=(*pseq)[pos-];

     return true;

 }

上述代码，调用了函数"fibon_seq()"，但除了fibon，还有其它5种数列和相应的"数列_seq()"函数：

 const vector<int> *lucas_seq(int size);

 const vector<int> *pell_seq(int size);

 //...

难道我们要实现其他5种“数列_elem()”？
可以发现在函数"fibon_elem()"中，唯一和数列相关的部分，只有（A）。如果我们可以消除这个关联性，就可以不必提供多个相似函数了。

所谓函数指针，必须指明其所指向之函数的返回值类型及参数表，此外，函数指针必须将*置于某个位置，表示这份定义所表现的是一个指针。当然，最后还必须给于一个名称。

const vector<int>* *seq_ptr(int); //几乎是对的了

但这其实不是我们所要的。上述这行将seq_ptr定义为一个函数，参数表中仅有一个int类型，返回值类型是个指针，这个指针指向另一个指针，后者指向一个const vector，其元素类型为int。为了让seq_ptr被视为一个指针，我们必须以小括号改变运算顺序：

const vector<int>* (*seq_ptr)(int); //ok

现在，seq_ptr可以指向“具有所列之返回值类型及参数表”的任何一个函数。让我们将fibon_elem()重新写国，使它蜕变成更为通用的seq_elem()：

 bool seq_elem( int pos, int &elem, const vector<int>* (*seq_ptr)(int))

 {

     //调用seq_ptr所指的函数

     const vector<int> *pseq=seq_ptr(pos);   //(A)

     if(!pseq)

     {

         elem=;

     return false;

     }

     elem=(*pseq)[pos-];

     return true;

 }

现在的问题是如何取得函数的地址呢？只要给于函数名称就可以了：

     //将pell_seq()地址赋给seq_ptr

     seq_ptr=pess_seq;

如何想把函数指针放入一个数组，可以这么定义：

     //seq_array是数组，内放函数指针

     const vector<int* (*seq_array[])(int)=

     {fibon_seq, lucas_seq, pell_seq, triang_seq, squqre_seq, pent_seq};

函数指针和指针函数区别

指针函数是指带指针的函数，即本质是一个函数。函数返回类型是某一类型的指针:

    //类型标识符    *函数名(参数表)

    int *f(x，y);

函数指针是指向函数的指针变量，即本质是一个指针变量。

    int (*f) (int x); /* 声明一个函数指针 */

    f=func; /* 将func函数的首地址赋给指针f */

2.9 设定头文件（Header Fiels）

调用seq_elem()之前，必须先声明它，以便让程序知道它的存在。如果它被5个程序文件调用，就必须调用5次。C++提供一种简单的方法，把函数声明置于头文件中，并在每个程序文件代码文件中含入（include）这些函数声明。

头文件的扩展名，习惯上是.h。标准程序库例外，它们没有扩展名。我把我们的头文件命名为NumSeq.h，并将于数列处理相关的所有函数的声明都置于此文件中：

 //NumSeq.h

 bool seq_elem(int pos, int &elem);

 const vector<int> *fibon_seq(int size);

 const vector<int> *lucas_seq(int size);

 const vector<int> *pell_seq(int size);

 //...

注意：函数的定义只能有一份，不过声明可以有很多份。我们不能把函数的定义纳入头文件，因为同一个程序的多个代码文件可能都会含入这个头文件。

“只定义一份”的规则有个例外：inlne函数的定义。为了能扩展inline函数的内容，在每个调用点上，编译器都得取得其定义。这意味着我们必须将inline函数的定义置于头文件中。

另外，const object和inline函数一样，是“一次定义规则”的例外。下面代码显示了把const object seq_cnt的定义加入到头文件NumSeq.h：

const int seq_cnt=;

为什么const object是是“一次定义规则”的例外？

　　因为const object的定义只要一出文件之外便不可见。这意味着我们可以在多个文件中加以定义，不会导致任何错误。

我们何时将const object加入头文件呢？

　　当它需要跨文件使用时。

如果想把指针放入头文件NumSeq.h，需要加上关键字extern：

const int seq_cnt=;

//seq_array是指向const object的指针

extern const vector<int>* (*seq_array[seq_cnt])(int);

以下代码是含入头文件iostream和NumSeq.h：

#include <iostream>

#include "NumSeq.h"

为什么头文件iostream用尖括号，而NumerSeq.h用双引号？

　　如果此文件被认定是标准的、或项目专属的头文件，我们便以尖括号括住：编译器搜索此文件时，会现在某些默认驱动器目录中寻找。

　　如果文件名由成队双引号括住，此文件便被认为是一个用户自行提供的头文件：编译器搜索此文件时，会由含入此文件所在的驱动器目录开始找起。

Reference