### 设置数组参数

在 C++中，数组参数是有争议的，因为在 C++标准中不存在数组参数，如果将数组作为函数参数，它将被视为指向第一个元素的指针传递到函数中。因此数组参数将采用引用传递方式。下面设计一个数组参数的函数，作用是对数组进行排序。

对数组进行排序

void Sort(int nArray[5]) //定义一个排序函数，使用数组作为参数

{

int nTmp = 0; //定义一个临时变量

for(int i=0; i<5; i++) //利用冒泡法排序

{

for(int j=0; j<5-i;j++)

{

if (nArray[j]>nArray[j+1]) //交换数组元素

{

nTmp = nArray[j];

nArray[j] = nArray[j+1];

nArray[j+1] = nTmp;

}

}

}

cout << "排序之后" <<endl;

for(i=0; i<5; i++) //输出排序后的结果

{

cout << nArray[i] << endl;

}

}

在 main 函数中定义一个数组，调用 Sort 函数对数组进行排序。

int main(int argc, char* argv[])

{

int nList[] = {78, 98, 75, 86, 78}; //定义一个数组

Sort(nList); //调用 Sort 函数

return 0;

}

运行程序，效果如图 1 所示。

图 1 数组参数

对于数组参数来说，由于它是一个指针，那么在定义数组参数时，数组的长度是没有意义的。例如，我们定义一个包含有 6 个元素的整型数组，然后调用 Sort 函数，尽管 Sort 函数的参数是一个包含 5 个元素的数组参数，但是仍然可以编译通过。

int main(int argc, char* argv[])

{

int nList[] = {78, 98, 75, 86, 78, 56}; //定义 6 个元素的整型数组

Sort(nList);

return 0;

}

运行结果与图 1 是完全相同的，因为在 Sort 函数中只对数组的前 5 个元素排序，第 6 个元素被忽略了。

因此在定义数组参数时，可以不指定数组的长度。例如，Sort 函数的声明可以采用如下的形式。

void Sort(int nArray[]) //不指定数组长度

既然数组参数被认为是一个指针，那么在 Sort 函数中能否将 nArray 参数修改为指针类型呢？当然可以，例如：

使用指针代替数组作为函数参数

void Sort(int *nArray) //定义一个排序函数，使用指针作为参数

{

int nTmp = 0; //定义一个临时变量

for(int i=0; i<5; i++) //利用冒泡法排序

{

for(int j=0; j<5-i;j++)

{

if (nArray[j]>nArray[j+1]) //交换数组元素

{

nTmp = nArray[j];

nArray[j] = nArray[j+1];

nArray[j+1] = nTmp;

}

}

}

cout << "排序之后" <<endl;

for(i=0; i<5; i++) //输出排序后的结果

{

cout << nArray[i] << endl;

}

}

在使用指针代替数组作为函数参数时，为了能够在函数体中知道数组的长度，以方便遍历数组元素，通用的做法是在函数中提供一个额外的参数表示数组的长度。例如，我们重新修改 Sort 函数，使其可以对任意长度的数组排序。

任意长度的数组参数

void Sort(int *nArray, int nLen) //定义一个排序函数，使用数组作为参数

{

int nTmp = 0; //定义一个临时变量

for(int i=0; i<nLen; i++) //利用冒泡法排序

{

for(int j=0; j<nLen-i;j++)

{

if (nArray[j]>nArray[j+1]) //交换数组元素

{

nTmp = nArray[j];

nArray[j] = nArray[j+1];

nArray[j+1] = nTmp;

}

}

}

cout << "排序之后" <<endl;

for(i=0; i<nLen; i++) //输出排序后的结果

{

cout << nArray[i] << endl;

}

}

这样，就可以对任意长度的数组排序了。例如：

int nList[] = {78, 98, 75, 86, 78, 56, 100}; //定义一个具有 7 个元素的整型数组

Sort(nList, 7); //调用 Sort 函数

当使用数组作为函数参数时，最佳的定义方式是使用不指定长度的数组作为参数，而不使用指针作为参数。例如：

void Sort(int nArray[], int nLen)

这样，能够更直观地让用户知道参数 nArray 表示一个数组。

在编写数组参数的函数时，有时需要限制用户传递指定长度的数组。例如，我们的函数参数要求数组的长度为 5，禁止用户传递 4 个元素或 6 个元素的数组。由于在调用数组参数的函数时，不检查数据长度，为了在语法上限制实际参数的数组长度，可以使用数组的引用。使用数组的引用作为函数参数。当数组的引用作为函数参数时，数组的长度将作为参数的一部分。例如：

限制指定长度的数组参数

void Sort(int (&nArray)[5]) //定义一个排序函数，使用数组引用作为参数

{

int nTmp = 0; //定义一个临时变量

for(int i=0; i<5; i++) //利用冒泡法排序

{

for(int j=0; j<5-i;j++)

{

if (nArray[j]>nArray[j+1]) //交换数组元素

{

nTmp = nArray[j];

nArray[j] = nArray[j+1];

nArray[j+1] = nTmp;

}

}

}

cout << "排序之后" <<endl;

for(i=0; i<5; i++) //输出排序后的结果

{

cout << nArray[i] << endl;

}

}

这样，如果为 Sort 函数传递一个不是 5 个元素的整型数组的实际参数，将导致编译错误。例如：

int nList[] = {78, 98, 75, 86, 78, 56}; //定义 6 个元素的整型数组

Sort(nList); //语法错误，不能够编译

在定义数组引用时，注意括号是能够省略的。如果将“int (&nArray)[5]”写为“int &nArray[5]”表示定义一个引用数组（数组中每一个元素都是一个引用对象），因为“[]”运算符的优先级高于“&”运算符。在 C++中定义引用数组是非法的，因此不存在“int &nArray[5]”形式的定义。

通过定义数组引用，我们可以得到一些启发，是否能够定义一个只能指向具体长度数组的指针呢？例如，定义一个整型指针，它只能够指向具有 5 个元素的数组。我们可以采用如下的形式。

int (*pList)[5]; //定义一个数组指针

这样 pList 就只能够指向 5 个元素的整型数组。例如：

int nList[] = {78, 98, 75, 86, 78, 56};

pList = &nList; //错误的语句，nList 包含 6 个元素

int nArray[]= {78, 98, 75, 86, 78};

pList = &nArray; //正确，nArray 包含 5 个元素