如何写优雅的代码（3）——合理选择函数形参

来源：互联网发布：如何看待网络信息安全编辑：程序博客网时间：2024/06/06 02:40

//========================================================================
    //TITLE:
    //    如何写优雅的代码（3）——合理选择函数形参
    //AUTHOR:
    //    norains
    //DATE:
    //    Tuesday 21-July-2009
    //Environment:
    //    WINCE5.0 + VS2005
    //========================================================================

    函数形参的确定，其实没有太多的讲究，一般而言，想怎么用就怎么用。但从C升级到C++的时候，偏偏给我们多出个引用。俗语道，当方法只有一种时，那是最幸福的。当我们需要改变形参的数值时，究竟是选择指针还是应用，这是我们追求优雅不得不考虑的幸福烦恼。

    以经典的交换两个int数值的代码做样例。

    采用指针的写法：

view plaincopy to clipboardprint?

BOOL Swap(int *piA,int *piB)
{
if(piA == NULL || piB == NULL)
{
return FALSE;
}
int iTemp = *piA;
*piA = *piB;
*piB = iTemp;
return TRUE;
}

采用引用的写法：

view plaincopy to clipboardprint?

BOOL Swap(int &iA,int &iB)
{
int iTemp = iA;
iA = iB;
iB = iA;
return TRUE;
}

调用的话，也是很简单：

view plaincopy to clipboardprint?

int WINAPI WinMain( HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPTSTR lpCmdLine,
int nCmdShow)
{
int iA = 1,iB = 2;
Swap(&iA,&iB); //调用指针
Swap(iA,iB); //调用引用
return 0;
}

  从功能的角度而言，无论是指针还是引用，都能实现同样的功能。很显然，我们不能通过能否实现某个功能来确定是采用引用还是指针。

  我们再来看看这两个函数，最大的区别在于指针还需要判断是否为NULL——对于指针而言，对为NULL值的指针提领，铁定会出现异常。故在比较之前，一定要判断指针的数值。也正是因为这个原因，以指针作为形参的Swap函数还有失败的可能性。但对于引用而言，则没有这个弊端，因为引用不能指向“无物”。由此，上述的采用引用的Swap其实根本不必要返回值，因为一定能够做到交换成功。

  精简后采用引用作为传递的Swap函数如下：

view plaincopy to clipboardprint?

void Swap(int &iA,int &iB)
{
int iTemp = iA;
iA = iB;
iB = iA;
}

  是不是比采用指针的更为清晰明了？


  是否可以下定论，用指针传递的都应该改用引用？当然答案是否定的。一般而言，当传递NULL可以相对改变函数意义时，我们可以也应该选择指针。

  我们在日常编程中会经常会碰到这么一种情形，给某一个函数传入一个缓冲区，然后往缓冲区复制数据。因为每次的数据大小都是不一致的，所以我们的缓冲区必须要以new来创建；而以new来创建缓冲，那么首先要确定数据的大小。这时候，我们就可以传入NULL值，告诉函数这次我们不需要拷贝数据，仅仅是想知道所需的大小而已。

  根据该情形，我们可以写出类似函数的模型：

view plaincopy to clipboardprint?

BOOL CopyBuffer(BYTE *pBuf,DWORD &dwLen)
{
if(IsRead() == FALSE)
{
return FALSE;
}
dwLen = g_dwLen;
if(pBuf != NULL && dwLen >= g_dwLen)
{
memcpy(pBuf,g_pBuf,g_dwLen);
}
if(pBuf != NULL && dwLen < g_dwLen)
{
return FALSE;
}
else
{
return TRUE;
}
}

调用的时候：

view plaincopy to clipboardprint?

//获取缓冲区大小
if(CopyBuffer(NULL,dwLen) != FALSE)
{
pBuf = new BYTE[dwLen];
//获取缓冲区数据
CopyBuffer(pBuf,dwLen);
}

  这样，我们就能够在不增加函数，不增加形参的情形下，只是通过NULL为标志确定缓冲区大小，进而分配相应的空间进行数据拷贝。

  细心的朋友看到这里，可能会说，这用引用也可以实现啊！因为对于这个函数而言，当传入的参数为0时，意味缓冲没意义，这个也可以作为标志啊！

  这当然也可以，所以CopyBuff就可以这样改：

view plaincopy to clipboardprint?

BOOL CopyBuffer(BYTE &buf,DWORD &dwLen)
{
if(IsRead() == FALSE)
{
return FALSE;
}
DWORD dwLenIn = dwLen;
dwLen = g_dwLen;
if(dwLenIn != 0)
{
if(dwLenIn >= g_dwLen)
{
memcpy(&buf,g_pBuf,g_dwLen);
}
else
{
return FALSE;
}
}
return TRUE;
}

  看起来是不是要比使用指针清爽？但问题不出在CopyBuffer函数，而在于调用上。

  因为CopyBuffer为引用，所以我们不能想这样调用：

view plaincopy to clipboardprint?

BYTE *pBuf = NULL;
CopyBuffer(pBuf,dwLen);

   这段代码会引发编译器会发生抱怨：error C2664: 'CopyBuffer' : cannot convert parameter 1 from 'BYTE *' to 'BYTE &'

   为了能让编译器安静，我们只能这样：

view plaincopy to clipboardprint?

BYTE *pBuf = NULL;
CopyBuffer(*pBuf,dwLen);

   编译器是高兴了，但运行就郁闷了。因为pBuf为NULL，所以*pBuf一定会异常。

   为避免这异常发生，我们在调用前只能先预分配一段缓冲区，故调用代码很可能如下类似：

view plaincopy to clipboardprint?

if(pBuf == NULL)
{
pBuf = new BYTE [DEFAULT_LENGTH];
}
//获取缓冲区大小
if(CopyBuffer(*pBuf,dwLen) != FALSE)
{
//删掉旧缓冲，建新缓冲区。
delete [] pBuf;
pBuf = new BYTE[dwLen];
//获取缓冲区数据
CopyBuffer(*pBuf,dwLen);
}

  相对之前采用指针作为形参的CopyBuffer，这样的调用显得更为累赘和繁琐。

  如上总结：作为函数的形参，只有当NULL有意义的时候，才选择指针；除此以外，都应该选择引用。

  这个结论，对于从C过渡到C++的朋友可能有点难以让人忍受。在C中，如果要改变形参的数值，就采用指针的方式，这样在调用的时候，能够在一定程度上了解该形参是否会被改变。

如：

view plaincopy to clipboardprint?

//形参有改变
GetData(&dwVal);
//形参不改变
SetData(dwVal);

而采用引用的方式，无论是否会改变形参值，在调用上都不会有任何蛛丝马迹：

view plaincopy to clipboardprint?

//形参有改变
GetData(dwVal);
//形参不改变
SetData(dwVal);

  也许最让郁闷的是，windows的api函数，凡是用来改变形参的，都无一例外是采用指针的形式。在这方面微软有充足的理由：让C程序员也能编写windows程序。只不过，我们已经上了C++这条贼船，为什么我们不用C++的方式呢？



  在很多情形下，以结构体作为形参，我们往往会带有const和引用的修饰：

view plaincopy to clipboardprint?

BOOL SetWindowPosition(const RECT &rcPos);

  const标明我们的态度，不对rcPos的数值进行变更；引用则是告诉编译器，不必为创建临时变量。

  也许这样说有点让人糊涂，还是让我们用实例来说明。当我们去掉const，去掉引用，则函数变成：

view plaincopy to clipboardprint?

BOOL SetWindowPosition(RECT rcPos);

  如果形参不是结构体类型，而是诸如DWORD，int等，那则无不妥；但如果是像例子中的结构体，那么编译器就要忙活了：创建一个对象，这就意味着要调用构造函数，使用完毕后还要析构函数清除。我们为了让编译器不那么辛苦，所以我们给形参加上引用的符号；又因为这个数值我们实在没打算更改，所以再加上const的修饰。于是，这函数就变成了之前我们所见到的形式。

  末尾，稍作总结：当传递结构体作为形参，不妨考虑一下const+引用的方式。