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

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

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

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

采用指针的写法：

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

采用引用的写法：

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

调用的话，也是很简单：

		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函数如下：

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

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


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

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

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

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

调用的时候：

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

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

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

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

  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为引用，所以我们不能想这样调用：

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

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

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

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

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

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

	  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中，如果要改变形参的数值，就采用指针的方式，这样在调用的时候，能够在一定程度上了解该形参是否会被改变。

如：

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

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

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

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



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

		BOOL SetWindowPosition(const RECT &rcPos);

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

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

		BOOL SetWindowPosition(RECT rcPos);

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

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